chore(deps): bump the cargo-dependencies group across 1 directory with 17 updates

Bumps the cargo-dependencies group with 17 updates in the / directory: | Package | From | To | | --- | --- | --- | | [serde_json](https://github.com/serde-rs/json) | `1.0.151` | `1.0.154` | | [skrifa](https://github.com/googlefonts/fontations) | `0.47.0` | `0.48.0` | | [harfrust](https://github.com/harfbuzz/harfrust) | `0.13.3` | `0.14.0` | | [vello_cpu](https://github.com/linebender/vello) | `0.2.0` | `0.3.0` | | [vello_common](https://github.com/linebender/vello) | `0.2.0` | `0.3.0` | | [i_overlay](https://github.com/iShape-Rust/iOverlay) | `9.0.0` | `9.1.0` | | [quick-xml](https://github.com/tafia/quick-xml) | `0.41.0` | `0.42.0` | | [zip](https://github.com/zip-rs/zip2) | `3.0.0` | `9.0.5` | | [egui](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [eframe](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [egui_kittest](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [arboard](https://github.com/1Password/arboard) | `3.6.1` | `3.7.0` | | [epaint_default_fonts](https://github.com/emilk/egui) | `0.36.2` | `0.37.0` | | [symphonia](https://github.com/pdeljanov/Symphonia) | `0.5.5` | `0.6.1` | | [hayro-syntax](https://github.com/LaurenzV/hayro) | `0.7.2` | `0.8.0` | | [cpal](https://github.com/RustAudio/cpal) | `0.16.0` | `0.18.2` | | [winresource](https://github.com/BenjaminRi/winresource) | `0.1.31` | `0.1.34` | Updates `serde_json` from 1.0.151 to 1.0.154 - [Release notes](https://github.com/serde-rs/json/releases) - [Commits](https://github.com/serde-rs/json/compare/v1.0.151...v1.0.154) Updates `skrifa` from 0.47.0 to 0.48.0 - [Release notes](https://github.com/googlefonts/fontations/releases) - [Changelog](https://github.com/googlefonts/fontations/blob/main/docs/RELEASE.md) - [Commits](https://github.com/googlefonts/fontations/compare/skrifa-v0.47.0...skrifa-v0.48.0) Updates `harfrust` from 0.13.3 to 0.14.0 - [Release notes](https://github.com/harfbuzz/harfrust/releases) - [Changelog](https://github.com/harfbuzz/harfrust/blob/main/CHANGELOG.md) - [Commits](https://github.com/harfbuzz/harfrust/compare/0.13.3...0.14.0) Updates `vello_cpu` from 0.2.0 to 0.3.0 - [Release notes](https://github.com/linebender/vello/releases) - [Changelog](https://github.com/linebender/vello/blob/v0.3.0/CHANGELOG.md) - [Commits](https://github.com/linebender/vello/compare/v0.2.0...v0.3.0) Updates `vello_common` from 0.2.0 to 0.3.0 - [Release notes](https://github.com/linebender/vello/releases) - [Changelog](https://github.com/linebender/vello/blob/v0.3.0/CHANGELOG.md) - [Commits](https://github.com/linebender/vello/compare/v0.2.0...v0.3.0) Updates `i_overlay` from 9.0.0 to 9.1.0 - [Release notes](https://github.com/iShape-Rust/iOverlay/releases) - [Commits](https://github.com/iShape-Rust/iOverlay/compare/9.0.0...9.1.0) Updates `quick-xml` from 0.41.0 to 0.42.0 - [Release notes](https://github.com/tafia/quick-xml/releases) - [Changelog](https://github.com/tafia/quick-xml/blob/master/Changelog.md) - [Commits](https://github.com/tafia/quick-xml/compare/v0.41.0...v0.42.0) Updates `zip` from 3.0.0 to 9.0.5 - [Release notes](https://github.com/zip-rs/zip2/releases) - [Changelog](https://github.com/zip-rs/zip2/blob/master/CHANGELOG.md) - [Commits](https://github.com/zip-rs/zip2/compare/v3.0.0...v9.0.5) Updates `egui` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `eframe` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `egui_kittest` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `arboard` from 3.6.1 to 3.7.0 - [Release notes](https://github.com/1Password/arboard/releases) - [Commits](https://github.com/1Password/arboard/compare/v3.6.1...v3.7.0) Updates `epaint_default_fonts` from 0.36.2 to 0.37.0 - [Release notes](https://github.com/emilk/egui/releases) - [Changelog](https://github.com/emilk/egui/blob/main/CHANGELOG.md) - [Commits](https://github.com/emilk/egui/compare/0.36.2...0.37.0) Updates `symphonia` from 0.5.5 to 0.6.1 - [Release notes](https://github.com/pdeljanov/Symphonia/releases) - [Commits](https://github.com/pdeljanov/Symphonia/compare/v0.5.5...v0.6.1) Updates `hayro-syntax` from 0.7.2 to 0.8.0 - [Commits](https://github.com/LaurenzV/hayro/commits/hayro-syntax-v0.8.0) Updates `cpal` from 0.16.0 to 0.18.2 - [Release notes](https://github.com/RustAudio/cpal/releases) - [Changelog](https://github.com/RustAudio/cpal/blob/master/CHANGELOG.md) - [Commits](https://github.com/RustAudio/cpal/compare/v0.16.0...v0.18.2) Updates `winresource` from 0.1.31 to 0.1.34 - [Commits](https://github.com/BenjaminRi/winresource/commits) --- updated-dependencies: - dependency-name: arboard dependency-version: 3.7.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: cpal dependency-version: 0.18.2 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: eframe dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: egui dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: egui_kittest dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: epaint_default_fonts dependency-version: 0.37.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: harfrust dependency-version: 0.14.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: hayro-syntax dependency-version: 0.8.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: i_overlay dependency-version: 9.1.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: quick-xml dependency-version: 0.42.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: serde_json dependency-version: 1.0.154 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: cargo-dependencies - dependency-name: skrifa dependency-version: 0.48.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: symphonia dependency-version: 0.6.1 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: vello_common dependency-version: 0.3.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: vello_cpu dependency-version: 0.3.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: cargo-dependencies - dependency-name: winresource dependency-version: 0.1.34 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: cargo-dependencies - dependency-name: zip dependency-version: 9.0.5 dependency-type: direct:production update-type: version-update:semver-major dependency-group: cargo-dependencies ... Signed-off-by: dependabot[bot] <support@github.com>
PDF: pin craft-pdf and krilla to craft-libs main (#1253 )
2026-10-24 10:37:03 -06:00 · 2026-10-24 02:42:13 +00:00 · 2026-10-23 22:37:28 -04:00 · 2026-10-23 19:56:24 -04:00 · 2026-10-23 19:29:43 -04:00 · 2026-10-23 17:28:02 -04:00
169 changed files with 5526 additions and 10215 deletions
@@ -1,55 +1,28 @@
-name: ci
+name: CI

-# Quality gates for every push to main and every pull request: rustfmt, clippy (-D warnings),
-# tests, asset attribution, crate layering and the wasm32 check — `cargo xtask ci`.
+# Quality gates for every push to main and every pull request (`cargo xtask ci`), through the
+# suite's shared gate workflow in craft-common-actions.
 on:
  push:
    branches: [main]
  pull_request:
  workflow_dispatch:

-concurrency:
-  group: ci-${{ github.ref }}
-  cancel-in-progress: true
+permissions:
+  contents: read

-env:
-  CARGO_TERM_COLOR: always
-  # Same craft-fonts commit as release.yml (Latin presentation fonts).
-  CRAFT_FONTS_REF: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+# A newer push to a PR branch cancels its older run; every push to main runs to the end.
+concurrency:
+  group: ci-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}

 jobs:
-  gates:
-    timeout-minutes: 60
-    name: gates (${{ matrix.os }})
-    strategy:
-      fail-fast: false
-      matrix:
-        # No macOS on PRs or main: the org's 5 macOS slots are kept for release builds, and
-        # release.yml builds macOS (a failing release is fixed and rebuilt).
-        os: [ubuntu-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      - name: Check out craft-fonts
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          repository: storytold/craft-fonts
-          ref: ${{ env.CRAFT_FONTS_REF }}
-          path: craft-fonts
-      - name: Linux build dependencies
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
-            libasound2-dev libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev libgl1-mesa-dev
-      - uses: dtolnay/rust-toolchain@686976e191b89faba57d3206551f0f330d8cb249 # stable
-        with:
-          components: rustfmt, clippy
-          targets: wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2.9.2
-        with:
-          key: ci-${{ matrix.os }}
-      - name: cargo xtask ci
-        env:
-          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
-        run: cargo xtask ci
+  gate:
+    # Tracks @main so suite-wide CI fixes reach every app without a PR in each repository.
+    uses: storytold/craft-common-actions/.github/workflows/gate.yml@main
+    with:
+      # Same craft-fonts commit as release.yml.
+      craft-fonts-ref: 43913056ce82a3fdad0ef69f6b88d1dc922a8104
+      packages: >-
+        libasound2-dev libxkbcommon-dev libwayland-dev libx11-dev libxrandr-dev libxi-dev
+        libgl1-mesa-dev
@@ -2,16 +2,17 @@
 # (GitHub has no FreeBSD runners). GPU tests skip themselves when the VM has no adapter.
 name: FreeBSD

+# The VM build is slow, so it runs nightly on main and on pushes to `release`, not on every pull
+# request: a drifted dependency still shows up within a day, and always before a release ships.
+# PRs that change the FreeBSD workflow itself still run it.
 on:
  push:
-    branches: [main]
+    branches: [release]
  pull_request:
    paths:
-      - Cargo.toml
-      - Cargo.lock
-      - "**/Cargo.toml"
-      - "crates/fonts/**"
      - .github/workflows/freebsd.yml
+  schedule:
+    - cron: "27 2 * * *"
  workflow_dispatch:

 concurrency:
@@ -11,7 +11,8 @@ permissions:

 concurrency:
  group: sonarcloud-${{ github.ref }}
-  cancel-in-progress: true
+  # A push to main is the run that publishes coverage; superseded runs there would never finish.
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}

 jobs:
  sonarcloud:
@@ -10,8 +10,9 @@ on:
    paths:
      - .github/workflows/windows-arm64.yml
      - packaging/windows/**
+  # Nightly, so dependency and runner-image drift shows up within a day.
  schedule:
-    - cron: "41 3 * * 1"
+    - cron: "3 5 * * *"
  workflow_dispatch:

 concurrency:
@@ -131,11 +131,12 @@ Standard: craftrules `standards/never-crash.md`.
  CLI, control channel and MCP do exactly the same thing.
 - **The UI is thin**: panels read engine state and act through commands. Colours come from theme
  tokens. **Never use Tauri**; egui only.
+- **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).
 - **Never break wasm** (`cargo xtask wasm`).

 ## 5. Quality gates (before every commit)

-`cargo xtask ci` = fmt check, clippy `-D warnings`, tests, layering check, asset check, wasm
+`cargo xtask ci` = fmt check, clippy `-D warnings`, tests (nextest when installed) and doctests, layering check, asset check, wasm
 check. Commit after each landed arc with a task id in the message (`M1.2: smart guides`) and push
 to `main`.

@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/deckcraft", "apps/deckcraft-cli"]

 [workspace.package]
-version = "0.9.0"
+version = "0.10.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
@@ -49,24 +49,27 @@ rayon = "1"
 unicode-bidi = "0.3"
 unicode-segmentation = "1"
 unicode-linebreak = "0.1"
-chrono = { version = "0.4", default-features = false, features = ["clock"] }
+# Base features are wasm-safe (`std` only). The non-wasm `clock` feature is requested
+# per-crate for targets that read the local clock (see crates/text).
+chrono = { version = "0.4", default-features = false, features = ["std"] }

 # text / rendering / formats
-skrifa = "0.47"
-harfrust = "0.13"
-vello_cpu = "0.2"
-vello_common = { version = "0.2", default-features = false }
+skrifa = "0.48"
+harfrust = "0.14"
+vello_cpu = "0.3"
+vello_common = { version = "0.3", default-features = false }
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif", "tiff", "bmp"] }
-craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "c3487320b2d1de657b860b3c8abb44e1f2b32bd8", version = "=0.1.0", default-features = false, features = ["write"] }
+craft-media = { git = "https://github.com/storytold/craft-libs", rev = "f0ad6c1e1d297908915f4be315b0fcfc9be7b5d4", version = "=0.1.0", default-features = false }
+craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef", version = "=0.1.0", default-features = false, features = ["write", "write-simple-text"] }
 i_overlay = "9"
-quick-xml = "0.41"
-zip = { version = "3", default-features = false, features = ["deflate"] }
+quick-xml = "0.42"
+zip = { version = "9", default-features = false, features = ["deflate"] }

 # ui
-egui = "0.36"
+egui = "0.37"
 egui_extras = { version = "0.36", default-features = false }
-eframe = { version = "0.36", default-features = false }
-egui_kittest = "0.36"
+eframe = { version = "0.37", default-features = false }
+egui_kittest = "0.37"
 rfd = "0.17"
 arboard = { version = "3.6", default-features = false }

@@ -82,11 +85,16 @@ self_named_constructors = "allow"
 large_enum_variant = "allow"
 result_large_err = "allow"

+# Line tables keep file and line in panics and backtraces; full debug info
+# for every test binary and dependency would multiply the target dir size.
+# The test profile inherits both settings.
 [profile.dev.package."*"]
 opt-level = 2
+debug = false

 [profile.dev]
 opt-level = 1
+debug = "line-tables-only"

 [profile.release]
 opt-level = 3
@@ -95,4 +103,4 @@ codegen-units = 16
 debug = 0

 [patch.crates-io]
-krilla = { git = "https://github.com/storytold/craft-libs", rev = "c3487320b2d1de657b860b3c8abb44e1f2b32bd8", version = "=0.8.2" }
+krilla = { git = "https://github.com/storytold/craft-libs", rev = "9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef", version = "=0.8.2" }
@@ -7,6 +7,10 @@
  </a>
 </p>

+<p align="center">
+  <img src="assets/app-icon/hicolor/256x256/apps/ai.storyteller.deckcraft.png" width="128" height="128" alt="DeckCraft icon: a presentation screen with a bar chart on an orange tile">
+</p>
+
 <h1 align="center">DeckCraft</h1>

 <p align="center">
@@ -220,6 +224,41 @@ DirectX 12 shaders are compiled with FXC, which is part of Windows, so no `dxcom

 RISC-V 64 (riscv64): `deckcraft-<ver>-linux-riscv64.tar.gz`, a tarball only (cross-compiled; needs glibc 2.39+, e.g. Ubuntu 24.04+).

+**Runtime libraries.** The window-system, GPU and file-dialog libraries DeckCraft needs are opened
+when the app starts (`dlopen` through `x11-dl`, `xkbcommon-dl`, `ash`, `glutin` and `rfd`) instead
+of being linked in, so `ldd` shows none of them: an install that satisfies the linked dependencies
+can still fail at start-up with a loader error and no hint of what to install. Only
+`libasound.so.2` (slide-show sound) is a hard link-time dependency, and only of the `deckcraft`
+GUI — `deckcraft-cli` uses neither sound nor a display. The `.deb` and `.rpm` declare the set in
+`packaging/linux/nfpm.yaml`; a tarball install or a musl system has to provide it itself:
+
+```sh
+apk add libx11 libxcursor libxrandr libxi libxkbcommon xkeyboard-config \
+        wayland-libs-client alsa-lib \
+        vulkan-loader mesa-vulkan-swrast \
+        mesa-gl mesa-egl mesa-dri-gallium \
+        xdg-desktop-portal
+```
+
+Alpine Linux `v3.22` names above; Void's musl variant uses the same `/lib/ld-musl-x86_64.so.1`
+loader and the same libraries as `libX11 libXcursor libXrandr libXi libxkbcommon xkeyboard-config
+wayland alsa-lib vulkan-loader mesa xdg-desktop-portal`. There is no musl build among the release
+artifacts yet — this is what a build from source on musl needs at run time, and what a future musl
+artifact will need (#954).
+
+- `mesa-vulkan-swrast` is the software Vulkan driver: it runs anywhere, VMs and containers
+  included. On a real GPU install your vendor's driver instead (`mesa-vulkan-intel`,
+  `mesa-vulkan-ati`, `mesa-vulkan-nouveau`, …).
+- Without Vulkan the app falls back to CPU rendering through Mesa's GL drivers. It works, but
+  slowly — a driver limit, not a DeckCraft bug.
+- `xdg-desktop-portal` (with `xdg-desktop-portal-gtk` or `-kde`; `-wlr` has no file chooser, so
+  on wlroots compositors install `zenity`) is what the Open and Save dialogs talk to; `xkeyboard-config` holds the XKB keyboard data `libxkbcommon` reads.
+- fontconfig and freetype are not needed: DeckCraft reads `/usr/share/fonts` itself and embeds its
+  presentation fonts.
+
+Building from source on musl also needs `build-base pkgconf alsa-lib-dev` (`alsa-lib-dev` is the
+ALSA headers).
+
 ### FreeBSD

 | Build | File |
@@ -2,7 +2,10 @@

 **Stage: alpha** · next: beta, ~20 points and ~120–210 h away

-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-18 · **Change:** minor (native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-23 · **Change:** trivial (progress log: scroll bars on the zoomed slide pane, #1157; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-22 · **Change:** trivial (fill and outline edits reach group members, #1079; stage and scores unchanged) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-20 · **Change:** trivial (empty chart number-format sections hide values; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-18 · **Change:** minor (Symbol-font characters (U+F0xx) remap to the installed Symbol face's real Unicode on macOS, so they draw from Symbol instead of a look-alike; previous: minor, native chart payloads stored in bounded ZIP members; previous: major, community PR wave 2026-10-14: ~60 landed items in the progress log, among them the Font, Paragraph, Photo Album, theme colour and font and Date and Time dialogs, presenter and show controls, the SmartArt Text Pane and PPTX corpus slices; breadth 84% after `cargo xtask parity`, ready stays ~55%, stage stays alpha; duplicated rows and headers folded; previous: minor, hours to ~95% per audience added) · **Target:** Microsoft PowerPoint for Mac 16.113 (Microsoft 365)

 DeckCraft aims at full PowerPoint parity, and to be better: faster, open (a documented zip+JSON
 format plus PPTX), scriptable by agents (CLI, JSON control channel, MCP), and available everywhere
@@ -131,15 +134,34 @@ app's JSON control channel (`deckcraft --control PORT`).

 | Date | What landed |
 |---|---|
+| 2026-10-23 | Format Background ▸ Apply to All also sets the background of the slide masters the slides use (and clears their layouts' overrides), so new slides keep it (#891) |
+| 2026-10-22 | Table text takes the master's other-text style (`otherStyle`), shapes and text boxes the presentation's default text style, as PowerPoint for Mac draws them (synthetic probe: 14 pt cells under a 14 pt `otherStyle` and a 26 pt `defaultTextStyle`); a private deck's table had been drawn 20 pt instead of 18 |
+| 2026-10-18 | Find (Ctrl+F): "Find what:" has the keyboard as soon as the dialog opens, and keeps it after Enter finds a match, so the search can be typed and changed without clicking the field (#951) |
+| 2026-10-18 | Duplicate (Ctrl+D) repeats a move: duplicate a shape, move the copy, and the next Duplicate places its copy the same distance further on, as in PowerPoint (#966) |
+| 2026-10-22 | Slide Show: while animations play, each frame draws only the slide's shapes over the slide's backdrop (background, master and layout graphics), rendered once and ahead of time. A full-slide picture with a glow in the layout re-rendered at every frame held animations to 2–3 frames a second (~390 ms a frame at 1080p); now ~28 ms |
+| 2026-10-22 | Animation Pane ▸ Play From: with an effect selected, the pane's play button starts the canvas preview at that effect, with the effects before it already played. With nothing selected it is still Play All |
+| 2026-10-21 | Opening a .pptx puts the text of shapes without an anchor at the top even when the theme's shape defaults (`spDef`) centre new shapes, as PowerPoint for Mac draws them; checked with a synthetic probe and on a private 166-deck corpus (51 slides closer to PowerPoint's PDF, none further) |
+| 2026-10-23 | A shape with no fill and no line (a text box) no longer draws its shape-level glow as a halo round its box; the text's own glow is all PowerPoint shows |
+| 2026-10-23 | Normal view: a slide zoomed past the window gets a horizontal and a vertical scroll bar on the axes that overflow; drag the thumb or click the track to reach every edge (#1157) |
+| 2026-10-22 | Shape Fill and Shape Outline format the members of a selected group, including nested groups, in one undo step. Fill transparency retains each member's effective colour (#1079) |
+| 2026-10-21 | 3-D contours, extrusion depths and bevels keep their size in points inside a group whose child coordinates scale its shapes: a 1 pt contour on a small extruded cube in a legacy group drew hundreds of points wide, a band across the slide |
+| 2026-10-20 | Chart number formats with explicit empty positive, negative or zero sections hide the corresponding labels, including all values with three semicolons; a blank whole format still uses General. Synthetic formatter regressions |
 | 2026-10-18 | Native chart sidecar bytes move from JSON arrays into referenced ZIP entries, with shared media byte/item limits and bounded reads; older inline sidecars still load. Synthetic format regressions cover large workbooks and malformed members |
+| 2026-10-18 | Slide thumbnails and the Slide Sorter render only the slides in view: on a deck of more than 600 slides they used to evict their own thumbnails, so the pane flashed white and never finished (#969) |
+| 2026-10-18 | Resizing with the mouse snaps the edge being dragged to the slide, guides and other shapes: a fixed edge that already lined up used to take the snap and leave the dragged edge free, and a fixed edge near a line shifted the dragged one (#961) |
+| 2026-10-18 | Slide show: a video or audio clip is looked up on the slide it belongs to, so slides whose shape ids repeat (the PPTX import numbers each slide afresh) no longer play each other's clips (#994) |
+| 2026-10-18 | About: Contributors and Models get their own fixed-size block below the tab row, so the tab row is no longer squeezed into the credits and the tabs keep answering (#843) |
+| 2026-10-19 | README: the Linux runtime libraries a tarball or musl install has to provide — the `dlopen`ed X11/Vulkan/GL/dialog libraries with their Alpine and Void package names, the software-Vulkan fallback, and why fontconfig and freetype are not among them (#955) |
 | 2026-10-17 | Opening a file caps absurd effect sizes (glow, soft edges, shadows, reflections, on shapes, text and table text) at what Format Shape allows: a glow of 10^18 pt in a .pptx made rendering ask for 34 GB and abort |
 | 2026-10-17 | Opening a .deckcraft file whose shapes repeat an id gives the repeats fresh ids (groups, layouts and masters too), so the deck validates and edits by id find one shape |
 | 2026-10-17 | Edit Points: turning a shape into a freeform is one undo step, so Undo brings the original shape back (it used to stay a freeform) |
 | 2026-10-17 | While a placeholder's text is being edited, a click on a shape in front of it selects that shape instead of moving the caret, as in PowerPoint (#931) |
+| 2026-10-16 | Symbol-font characters: a run's U+F0xx symbol code (from `<a:sym typeface="Symbol"/>`) now draws from the installed Symbol face even when it has no private-use mapping — Apple's Symbol on macOS maps the glyphs to real Unicode, so the code is remapped to that character (the Adobe Symbol encoding) instead of falling to a look-alike. Bullets and metafile text take the same remap |
 | 2026-10-15 | Native saves keep an imported chart's embedded workbook, drawings and relationships; headless PPTX → edit → native save/reopen → PPTX tests verify the payloads and stale-workbook rejection |
 | 2026-10-15 | PPTX trigger sequences keep separate On Click steps, including paragraph builds; synthetic import/edit/save/reopen and headless show regressions |
 | 2026-10-16 | Export: PNG with a transparent background — the slide background is left out, only the slide's content is drawn (Export… dialog, File › Export, web download, `file.export`/`file.render` `transparentBackground`, `deckcraft-cli render --transparent`) (#784) |
 | 2026-10-16 | Arrange ▸ Align: Align to Slide and Align Selected Objects, as in PowerPoint. One object aligns to the slide and several to each other until the other choice is ticked; the choice holds for that selection and also drives Distribute |
+| 2026-10-16 | Fitted canvas: discrete mouse-wheel steps navigate immediately, including rapid and batched input, while trackpad gestures retain their cooldown and zoomed slides still pan. |
 | 2026-10-15 | CLI: .txt and .md export includes table cell text, which it used to skip silently (#814) |
 | 2026-10-15 | A `.pptx` slide that can't be read is reported, not dropped in silence: `lostSlides` from `file.open`, a message and a repaired copy in the app, a warning from `deckcraft-cli` (#203) |
 | 2026-10-16 | AutoFormat as you type: ordinals (1st, 22nd, 103rd) get superscript suffixes after a space or punctuation; Tools ▸ AutoCorrect and `text.autocorrect {ordinals}` turn it off |
@@ -240,11 +262,20 @@ app's JSON control channel (`deckcraft --control PORT`).

 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-22 | trivial | Progress log: Animation Pane ▸ Play From. Scores unchanged |
+| 2026-10-23 | trivial | Progress log: scroll bars on the zoomed slide pane (#1157). Scores and milestone names unchanged |
+| 2026-10-20 | trivial | Explicit empty chart number-format sections hide their values; blank whole-code General fallback is retained. Synthetic formatter regressions; chart-element scores and readiness estimates unchanged |
 | 2026-10-18 | minor | Native chart payloads use referenced ZIP members and share media byte/item limits; old inline sidecars remain readable. Synthetic tests cover multi-megabyte layout, all shape owners, shared budgets, missing/corrupt members and invalid references. Scores and milestone scope unchanged |
+| 2026-10-16 | minor | Symbol-font U+F0xx codes remap to the installed Symbol face's real Unicode (Apple Symbol on macOS) |
 | 2026-10-15 | trivial | Progress log: chart package parts survive a native save. Scores and milestone names unchanged |
+| 2026-10-18 | trivial | Progress log: thumbnails of huge decks render only the slides in view (#969) |
 | 2026-10-15 | trivial | Progress log: PPTX trigger click-step round trip. Feature scores and milestone names unchanged |
 | 2026-10-16 | trivial | Progress log: PNG export with a transparent background (#784) |
 | 2026-10-16 | trivial | Progress log: a `.ppsx` from the system starts the slide show (#862) |
+| 2026-10-22 | trivial | Progress log: table text takes the master's other-text style |
+| 2026-10-16 | trivial | Progress log: responsive mouse-wheel navigation on the fitted canvas |
+| 2026-10-21 | trivial | Progress log: theme `spDef` anchor no longer applied to a file's own shapes |
+| 2026-10-21 | trivial | Progress log: 3-D sizes in scaled groups stay in points |
 | 2026-10-14 | trivial | remote MCP checks reply IDs, envelopes and bounded newline framing (#718) |
 | 2026-10-14 | minor | Gray list markers on empty paragraphs while editing; caret keeps the list indent before typing |
 | 2026-10-14 | minor | Community PR wave folded: headline breadth 84% over 191 features (P0 92%, P1 82%, P2 55%) and the feature-area breadths from `cargo xtask parity`; one row per area; Upcoming item 2 merged; per-PR count notes dropped from the progress log. Ready stays ~55%, stage alpha |
@@ -0,0 +1,6 @@
+mod cli;
+mod convert;
+mod damaged;
+// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md).
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod mcp_roots;
@@ -1,6 +1,4 @@
 //! `deckcraft-cli mcp` with the automation root flags, run as the real binary.
-// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md).
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]

 use std::io::Write;
 use std::path::PathBuf;
@@ -18,6 +18,7 @@ eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit", "
 egui = { workspace = true }
 serde_json = { workspace = true }
 log = { workspace = true }
+chrono = { workspace = true }

 [build-dependencies]
 # Icon + VERSIONINFO for deckcraft.exe; build.rs only uses it when the target is Windows.
@@ -27,7 +28,7 @@ winresource = "0.1"
 rfd = { workspace = true }
 arboard = { workspace = true, features = ["image-data"] }
 image = { workspace = true }
-cpal = "0.16"
+cpal = "0.18"

 [target.'cfg(target_os = "macos")'.dependencies]
 # Finder double-click, Open With, Dock drops and `open -a DeckCraft deck.pptx` arrive as a
@@ -8,11 +8,11 @@
 //! socket may sit idle or blocked on a write.

 use std::io::{BufRead, BufReader, ErrorKind, Read, Write};
-use std::net::{TcpListener, TcpStream};
+use std::net::{Shutdown, TcpListener, TcpStream};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::mpsc::{Receiver, SyncSender, TrySendError, sync_channel};
-use std::time::Duration;
+use std::time::{Duration, Instant};

 use deckcraft_ui_egui::ControlRequest;
 use serde_json::{Value, json};
@@ -61,12 +61,22 @@ pub fn start(port: u16, ctx: egui::Context) -> Receiver<ControlRequest> {
    }
 }

+/// How long the accepting thread waits after a failed accept. Accepting can keep failing, for
+/// example while the process has no file descriptors left, and retrying at once would keep a
+/// core busy until it recovers.
+const ACCEPT_RETRY: Duration = Duration::from_millis(100);
+
+/// The connections `incoming` accepts, calling `wait` after each failed accept.
+fn accepted<T>(incoming: impl Iterator<Item = std::io::Result<T>>, mut wait: impl FnMut()) -> impl Iterator<Item = T> {
+    incoming.filter_map(move |stream| stream.map_err(|_| wait()).ok())
+}
+
 /// Accept connections on `listener` under `limits`; requests arrive on the returned receiver.
 fn serve_listener(listener: TcpListener, limits: Limits, ctx: egui::Context) -> Receiver<ControlRequest> {
    let (tx, rx) = sync_channel::<ControlRequest>(limits.queue.max(1));
    let active = Arc::new(AtomicUsize::new(0));
    std::thread::spawn(move || {
-        for mut stream in listener.incoming().flatten() {
+        for mut stream in accepted(listener.incoming(), || std::thread::sleep(ACCEPT_RETRY)) {
            let _ = stream.set_write_timeout(Some(limits.write_timeout));
            if active.fetch_add(1, Ordering::SeqCst) >= limits.max_clients {
                active.fetch_sub(1, Ordering::SeqCst);
@@ -170,6 +180,35 @@ fn is_http_request_line(text: &str) -> bool {
        || text.rsplit_once(' ').is_some_and(|(_, version)| version.starts_with("HTTP/"))
 }

+/// Close after the last reply so the peer can still read it. A peer that had sent another line
+/// before the reply arrived -- two lines in one write, which any script does -- leaves input
+/// unread in the socket, and closing a socket with unread input resets the connection: the reply
+/// already queued for the peer is discarded and it sees only the reset. Sending the FIN first and
+/// then draining, briefly and boundedly, makes the close orderly and the reason survive.
+fn close_politely(out: &TcpStream, reader: &mut BufReader<TcpStream>, grace: Duration) {
+    if out.shutdown(Shutdown::Write).is_err() {
+        return;
+    }
+    // Enough for a pipelined line or two; a peer that keeps talking is dropped at the deadline.
+    // The timeout is what is left of the grace before each read, not the whole of it: a peer that
+    // sends a byte just before each one expires would otherwise hold this thread, and its slot,
+    // for close to twice as long as the deadline says.
+    const MAX_DRAIN: usize = 64 << 10;
+    let until = Instant::now() + grace;
+    let mut sink = [0u8; 4 << 10];
+    let mut drained = 0;
+    while drained < MAX_DRAIN {
+        let left = until.saturating_duration_since(Instant::now());
+        if left.is_zero() || out.set_read_timeout(Some(left)).is_err() {
+            break;
+        }
+        match reader.read(&mut sink) {
+            Ok(0) | Err(_) => break,
+            Ok(n) => drained += n,
+        }
+    }
+}
+
 fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context, limits: Limits) {
    if stream.set_read_timeout(Some(limits.idle_timeout)).is_err() || stream.set_write_timeout(Some(limits.write_timeout)).is_err() {
        return;
@@ -182,6 +221,7 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
            Line::Text(t) => t,
            Line::TooLong => {
                let _ = writeln!(out, "{}", json!({"ok": false, "error": format!("request line longer than {} bytes", limits.max_line)}));
+                close_politely(&out, &mut reader, limits.write_timeout);
                break;
            }
            Line::Closed => break,
@@ -189,8 +229,11 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
        let reply = match parse(&line) {
            Parsed::Blank => continue,
            Parsed::Reject(e) => {
-                // The connection closes either way; a peer that can't read the reason loses nothing.
+                // The connection closes either way, but the peer is told why first: see
+                // `close_politely`, without which a peer that had pipelined another line had this
+                // reply reset away and saw nothing.
                let _ = writeln!(out, "{}", json!({"ok": false, "error": e}));
+                close_politely(&out, &mut reader, limits.write_timeout);
                break;
            }
            Parsed::Request { id, method, params } => {
@@ -234,6 +277,18 @@ fn serve(stream: TcpStream, tx: &SyncSender<ControlRequest>, ctx: &egui::Context
 #[cfg(test)]
 mod tests {
    use super::*;
+
+    /// A failed accept is followed by a wait before the next one, so a listener that keeps
+    /// failing does not spin, and the connections around the failures still come through.
+    #[test]
+    fn a_failed_accept_waits_before_the_next() {
+        let failed = || Err(std::io::Error::other("no file descriptors left"));
+        let incoming = vec![failed(), Ok(1), failed(), failed(), Ok(2)];
+        let mut waits = 0;
+        let connections: Vec<i32> = super::accepted(incoming.into_iter(), || waits += 1).collect();
+        assert_eq!(connections, [1, 2]);
+        assert_eq!(waits, 3, "one wait per failed accept");
+    }
    use std::net::SocketAddr;
    use std::time::Instant;

@@ -327,6 +382,27 @@ mod tests {
        assert!(!is_http_request_line("{\"method\":\"GET /\"}"));
    }

+    /// A peer that pipelines -- two lines in one write, as a script does -- still reads why its
+    /// line was rejected. Closing with its second line unread resets the connection and discards
+    /// the reply already on its way, so the peer saw nothing at all; repeated here because it
+    /// depended on the timing of the two.
+    #[test]
+    fn a_pipelined_peer_still_reads_why_its_line_was_rejected() {
+        let (addr, rx) = server(small());
+        for _ in 0..12 {
+            let (mut r, mut w) = client(addr);
+            w.write_all(b"hello\n").unwrap();
+            // A second line, written after the first as a script writes it: it races the close.
+            let _ = w.write_all(b"{\"id\":2,\"method\":\"m\"}\n");
+            let replies = replies_until_closed(&mut r);
+            assert_eq!(replies.len(), 1, "{replies:?}");
+            assert_eq!(replies[0]["ok"], false);
+            assert!(replies[0]["error"].as_str().unwrap_or_default().contains("closing the connection"), "{replies:?}");
+        }
+        // The line after the rejected one is never dispatched, pipelined or not.
+        assert!(rx.try_recv().is_err(), "a line after the rejection was dispatched");
+    }
+
    #[test]
    fn oversized_line_closes_connection() {
        let (addr, rx) = server(small());
@@ -95,29 +95,35 @@ fn matches(name: &str, target: &str) -> bool {
    }
 }

-/// `2026-10-08T07:59:17.728Z` (UTC, milliseconds). A clock before 1970 reads as the epoch.
+/// `2026-10-08T07:59:17.728Z` (UTC, milliseconds). A clock before 1970 reads as the epoch; a clock
+/// set absurdly far ahead keeps its real year (years far outside chrono's own range are preserved)
+/// instead of panicking.
 pub fn timestamp(t: SystemTime) -> String {
    let since = t.duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
-    let secs = since.as_secs();
-    let (days, rem) = (secs / 86_400, secs % 86_400);
-    let (y, m, d) = civil_from_days(days);
-    format!("{y:04}-{m:02}-{d:02}T{:02}:{:02}:{:02}.{:03}Z", rem / 3600, rem % 3600 / 60, rem % 60, since.subsec_millis())
+    let (y, dt) = utc_parts(since.as_secs(), since.subsec_nanos());
+    // `{:04}` rather than `%Y`, which writes a `+` before years past 9999.
+    format!("{y:04}-{}", dt.format("%m-%dT%H:%M:%S%.3fZ"))
 }

-/// Days since 1970-01-01 to a proleptic Gregorian (year, month, day) (Howard Hinnant's
-/// `civil_from_days`, unsigned because `timestamp` clamps at the epoch; saturating so an absurd
-/// clock can't overflow).
-fn civil_from_days(days: u64) -> (u64, u64, u64) {
-    let z = days.saturating_add(719_468);
-    let era = z / 146_097;
-    let doe = z % 146_097;
-    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
-    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-    let mp = (5 * doy + 2) / 153;
-    let d = doy - (153 * mp + 2) / 5 + 1;
-    let m = if mp < 10 { mp + 3 } else { mp - 9 };
-    let y = era.saturating_mul(400).saturating_add(yoe).saturating_add(u64::from(m <= 2));
-    (y, m, d)
+/// Unix seconds (+ nanos) → (proleptic Gregorian year, the same wall-clock instant moved into
+/// chrono's range by whole 400-year cycles). The Gregorian calendar repeats every 400 years
+/// (146_097 days), so month, day and time of day come from chrono and only the year is carried,
+/// which keeps every input exact instead of collapsing out-of-range years to the epoch. `secs` is
+/// `u64` (the clock is clamped at the epoch before 1970), so `days` always fits an `i64`.
+fn utc_parts(secs: u64, nanos: u32) -> (i64, chrono::NaiveDateTime) {
+    use chrono::Datelike;
+    let (days, sod) = ((secs / 86_400) as i64, (secs % 86_400) as i64);
+    let (cycles, rest) = (days.div_euclid(146_097), days.rem_euclid(146_097));
+    // `rest + 719_163` (1970-01-01 is CE day 719_163) is always a valid CE day, and `sod` < 86_400.
+    let date = i32::try_from(rest + 719_163).ok().and_then(chrono::NaiveDate::from_num_days_from_ce_opt);
+    let time = u32::try_from(sod).ok().and_then(|s| chrono::NaiveTime::from_num_seconds_from_midnight_opt(s, nanos.min(999_999_999)));
+    match (date, time) {
+        (Some(d), Some(t)) => {
+            let y = i128::from(d.year()) + i128::from(cycles) * 400;
+            (i64::try_from(y).unwrap_or(i64::MAX), d.and_time(t))
+        }
+        _ => (1970, chrono::NaiveDateTime::default()), // unreachable
+    }
 }

 fn numbered(dir: &Path, n: usize) -> PathBuf {
@@ -389,6 +395,17 @@ mod tests {
        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(4_107_542_400)), "2100-03-01T00:00:00.000Z");
        // Before the epoch (a clock set wrong) clamps instead of panicking.
        assert_eq!(timestamp(UNIX_EPOCH - Duration::from_secs(5)), "1970-01-01T00:00:00.000Z");
+        // A clock set absurdly far ahead (past chrono's own range) keeps its real year rather than
+        // collapsing to the epoch. Windows' SystemTime can't hold such an instant, so it is built
+        // with a checked add and only asserted where it exists.
+        if let Some(far) = UNIX_EPOCH.checked_add(Duration::from_secs(u64::MAX / 2)) {
+            assert_eq!(timestamp(far), "292277026596-12-04T15:30:07.000Z");
+        }
+        if let Some(far) = UNIX_EPOCH.checked_add(Duration::from_secs(10_000_000_000_000)) {
+            assert_eq!(timestamp(far), "318857-05-20T17:46:40.000Z");
+        }
+        // Years past 9999 keep the plain zero-padded year (no `+`).
+        assert_eq!(timestamp(UNIX_EPOCH + Duration::from_secs(253_402_300_800)), "10000-01-01T00:00:00.000Z");
    }

    #[test]
@@ -344,6 +344,36 @@ fn empty_slide() {
    assert_eq!(tl.locate(5.0), (0, 0.0));
 }

+#[test]
+fn start_of_seeks_the_play_all_clock_to_an_effect() {
+    let mut late = anim(4, AnimClass::Entrance, "fade", AnimStart::WithPrevious);
+    late.delay_ms = 250;
+    let mut triggered = anim(4, AnimClass::Emphasis, "pulse", AnimStart::OnClick);
+    triggered.trigger = Some(ShapeId(1));
+    let tl = Timeline::new(
+        &slide_with(vec![
+            anim(1, AnimClass::Entrance, "fade", AnimStart::OnClick),
+            anim(2, AnimClass::Exit, "fadeOut", AnimStart::OnClick),
+            anim(3, AnimClass::Entrance, "fade", AnimStart::OnClick),
+            late,
+            triggered,
+        ]),
+        W,
+        H,
+    );
+    assert_eq!(tl.start_of(0), Some(0.0));
+    assert_eq!(tl.start_of(2), Some(2.0));
+    assert_eq!(tl.start_of(3), Some(2.25));
+    assert_eq!(tl.start_of(4), None, "a triggered effect is not on the play-all clock");
+    assert_eq!(tl.start_of(9), None);
+    // Playing from the third effect: what came before has played, the rest has not.
+    let at = tl.start_of(2).unwrap();
+    assert!(tl.state_at(ShapeId(1), None, at).visible, "entered before");
+    assert!(!tl.state_at(ShapeId(2), None, at).visible, "exited before");
+    assert!(!tl.state_at(ShapeId(3), None, at).visible, "not entered yet");
+    assert!(!tl.state_at(ShapeId(4), None, at).visible, "not entered yet");
+}
+
 #[test]
 fn locate_play_all_clock() {
    let tl = Timeline::new(
@@ -359,6 +359,19 @@ impl Timeline {
        (self.main.len(), 0.0)
    }

+    /// Where effect `anim` (index into `slide.animations`) starts on the play-everything clock:
+    /// Animation Pane ▸ Play From. `None` for a triggered effect or one that isn't on the slide.
+    pub fn start_of(&self, anim: usize) -> Option<f64> {
+        let e = self
+            .effects
+            .iter()
+            .map(|e| &e.timing)
+            .filter(|e| e.anim == anim && e.sequence == Sequence::Main)
+            .min_by(|a, b| a.step.cmp(&b.step).then(a.start.total_cmp(&b.start)))?;
+        let before: f64 = self.main.iter().take(e.step).map(|s| s.duration).sum();
+        Some(before + e.start)
+    }
+
    /// Shapes that start an interactive sequence when clicked.
    pub fn trigger_shapes(&self) -> Vec<ShapeId> {
        self.triggers.iter().map(|(s, _)| *s).collect()
@@ -9,6 +9,4 @@ rust-version.workspace = true
 workspace = true

 [dependencies]
-
-[dev-dependencies]
-proptest = { workspace = true }
+craft-media = { workspace = true, features = ["bitstream"] }
@@ -1,495 +1,14 @@
-//! Bit-level reading and writing shared by DeckCraft's codec crates (ported from FilmCraft).
+//! Bit-level reading and writing for DeckCraft's codec crates: a re-export of
+//! [`craft_media::bitstream`] from craft-libs, plus [`budget`].
 //!
 //! - [`BitReader`]: MSB-first reader with Exp-Golomb (`ue(v)`, `se(v)`), as used by H.264/HEVC/AV1 headers.
 //! - [`BitWriter`]: the matching writer (for encoders and header rewriting).
 //! - [`unescape_rbsp`] / [`escape_rbsp`]: remove/insert H.264/HEVC emulation-prevention bytes.
-//! - [`budget`]: the memory budget video decoders check their picture store against.
 //! - [`annexb_nals`] / [`length_prefixed_nals`]: split Annex-B byte streams and AVCC/HVCC samples into NAL units.
+//! - [`budget`]: the memory budget video decoders check their picture store against.

 #![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable))]

-use std::fmt;
+pub use craft_media::bitstream::*;

 pub mod budget;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum BitError {
-    /// Tried to read past the end of the buffer.
-    Eof,
-    /// An Exp-Golomb code longer than 32 leading zeros.
-    InvalidExpGolomb,
-    /// A NAL length prefix width outside 1..=4 bytes.
-    InvalidLengthSize,
-}
-
-impl fmt::Display for BitError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            BitError::Eof => f.write_str("unexpected end of bitstream"),
-            BitError::InvalidExpGolomb => f.write_str("invalid Exp-Golomb code"),
-            BitError::InvalidLengthSize => f.write_str("unsupported NAL length prefix size"),
-        }
-    }
-}
-impl std::error::Error for BitError {}
-
-pub type Result<T> = std::result::Result<T, BitError>;
-
-/// MSB-first bit reader over a byte slice.
-#[derive(Clone)]
-pub struct BitReader<'a> {
-    data: &'a [u8],
-    /// Position in bits.
-    pos: usize,
-}
-
-impl<'a> BitReader<'a> {
-    pub fn new(data: &'a [u8]) -> Self {
-        Self { data, pos: 0 }
-    }
-    pub fn data(&self) -> &'a [u8] {
-        self.data
-    }
-    /// Bit position from the start.
-    pub fn position(&self) -> usize {
-        self.pos
-    }
-    pub fn bits_left(&self) -> usize {
-        (self.data.len() * 8).saturating_sub(self.pos)
-    }
-    pub fn is_byte_aligned(&self) -> bool {
-        self.pos.is_multiple_of(8)
-    }
-    pub fn byte_align(&mut self) {
-        self.pos = self.pos.div_ceil(8) * 8;
-    }
-    /// Byte offset of the current position (rounded down).
-    pub fn byte_pos(&self) -> usize {
-        self.pos / 8
-    }
-    pub fn seek_bits(&mut self, pos: usize) {
-        self.pos = pos;
-    }
-
-    /// Peek up to 32 bits without consuming (zero-padded past the end).
-    #[inline]
-    pub fn peek(&self, n: u32) -> u32 {
-        debug_assert!(n <= 32);
-        if n == 0 {
-            return 0;
-        }
-        let byte = self.pos / 8;
-        let shift = self.pos % 8;
-        let mut v: u64 = 0;
-        for i in 0..5 {
-            v = (v << 8) | *self.data.get(byte + i).unwrap_or(&0) as u64;
-        }
-        // v holds 40 bits starting at `byte`
-        ((v << (24 + shift)) >> (64 - n)) as u32
-    }
-
-    #[inline]
-    pub fn read_bits(&mut self, n: u32) -> Result<u32> {
-        if n as usize > self.bits_left() {
-            return Err(BitError::Eof);
-        }
-        let v = self.peek(n);
-        self.pos += n as usize;
-        Ok(v)
-    }
-
-    pub fn read_bits_u64(&mut self, n: u32) -> Result<u64> {
-        if n <= 32 {
-            return self.read_bits(n).map(u64::from);
-        }
-        let hi = self.read_bits(n - 32)? as u64;
-        let lo = self.read_bits(32)? as u64;
-        Ok((hi << 32) | lo)
-    }
-
-    #[inline]
-    pub fn read_bit(&mut self) -> Result<bool> {
-        self.read_bits(1).map(|b| b == 1)
-    }
-    pub fn read_flag(&mut self) -> Result<bool> {
-        self.read_bit()
-    }
-
-    pub fn skip(&mut self, n: usize) -> Result<()> {
-        if n > self.bits_left() {
-            return Err(BitError::Eof);
-        }
-        self.pos += n;
-        Ok(())
-    }
-
-    /// Unsigned Exp-Golomb `ue(v)`.
-    pub fn read_ue(&mut self) -> Result<u32> {
-        let mut zeros = 0u32;
-        while !self.read_bit()? {
-            zeros += 1;
-            if zeros > 32 {
-                return Err(BitError::InvalidExpGolomb);
-            }
-        }
-        if zeros == 0 {
-            return Ok(0);
-        }
-        let v = self.read_bits_u64(zeros)?;
-        let r = (1u64 << zeros) - 1 + v;
-        u32::try_from(r).map_err(|_| BitError::InvalidExpGolomb)
-    }
-
-    /// `ue(v) + add` (the `..._minus1` / `..._minus8` fields), failing instead of overflowing on a
-    /// hostile value near `u32::MAX`.
-    pub fn read_ue_plus(&mut self, add: u32) -> Result<u32> {
-        self.read_ue()?.checked_add(add).ok_or(BitError::InvalidExpGolomb)
-    }
-
-    /// Signed Exp-Golomb `se(v)`. Codes whose value does not fit an `i32` (the code for `2^31`) are rejected.
-    pub fn read_se(&mut self) -> Result<i32> {
-        let k = self.read_ue()? as i64;
-        let v = if k & 1 == 1 { (k + 1) / 2 } else { -(k / 2) };
-        i32::try_from(v).map_err(|_| BitError::InvalidExpGolomb)
-    }
-
-    /// Truncated Exp-Golomb `te(v)` with range `max`.
-    pub fn read_te(&mut self, max: u32) -> Result<u32> {
-        if max > 1 { self.read_ue() } else { Ok(!self.read_bit()? as u32) }
-    }
-
-    /// H.264/HEVC `more_rbsp_data()`: true if there is data before the rbsp trailing bits.
-    pub fn more_rbsp_data(&self) -> bool {
-        let total = self.data.len() * 8;
-        if self.pos >= total {
-            return false;
-        }
-        // find last set bit (the rbsp_stop_one_bit)
-        let mut last = None;
-        for (i, &b) in self.data.iter().enumerate().rev() {
-            if b != 0 {
-                last = Some(i * 8 + 7 - b.trailing_zeros() as usize);
-                break;
-            }
-        }
-        match last {
-            Some(stop) => self.pos < stop,
-            None => false,
-        }
-    }
-}
-
-/// MSB-first bit writer.
-#[derive(Default, Clone)]
-pub struct BitWriter {
-    buf: Vec<u8>,
-    acc: u64,
-    nbits: u32,
-}
-
-impl BitWriter {
-    pub fn new() -> Self {
-        Self::default()
-    }
-    pub fn write_bits(&mut self, value: u32, n: u32) {
-        debug_assert!(n <= 32);
-        if n == 0 {
-            return;
-        }
-        let v = (value as u64) & ((1u64 << n) - 1);
-        self.acc = (self.acc << n) | v;
-        self.nbits += n;
-        while self.nbits >= 8 {
-            self.nbits -= 8;
-            self.buf.push((self.acc >> self.nbits) as u8);
-        }
-        self.acc &= (1u64 << self.nbits) - 1;
-    }
-    pub fn write_bit(&mut self, b: bool) {
-        self.write_bits(b as u32, 1);
-    }
-    pub fn write_ue(&mut self, v: u32) {
-        self.write_ue_u64(v as u64);
-    }
-    fn write_ue_u64(&mut self, v: u64) {
-        let x = v + 1;
-        let len = 64 - x.leading_zeros();
-        let zeros = len - 1;
-        for _ in 0..zeros {
-            self.write_bit(false);
-        }
-        if len > 32 {
-            self.write_bits((x >> 32) as u32, len - 32);
-            self.write_bits(x as u32, 32);
-        } else {
-            self.write_bits(x as u32, len);
-        }
-    }
-    /// Signed Exp-Golomb `se(v)`. `i32::MIN` needs a code above `u32::MAX`, which `read_se` rejects.
-    pub fn write_se(&mut self, v: i32) {
-        let v = v as i64;
-        let k = if v > 0 { (v as u64) * 2 - 1 } else { ((-v) as u64) * 2 };
-        self.write_ue_u64(k);
-    }
-    pub fn bit_len(&self) -> usize {
-        self.buf.len() * 8 + self.nbits as usize
-    }
-    pub fn is_byte_aligned(&self) -> bool {
-        self.nbits == 0
-    }
-    /// Pad with zero bits to a byte boundary.
-    pub fn align_zero(&mut self) {
-        if self.nbits > 0 {
-            self.write_bits(0, 8 - self.nbits);
-        }
-    }
-    /// `rbsp_trailing_bits()`: a one bit then zeros to alignment.
-    pub fn rbsp_trailing(&mut self) {
-        self.write_bit(true);
-        self.align_zero();
-    }
-    pub fn write_bytes(&mut self, bytes: &[u8]) {
-        if self.nbits == 0 {
-            self.buf.extend_from_slice(bytes);
-        } else {
-            for &b in bytes {
-                self.write_bits(b as u32, 8);
-            }
-        }
-    }
-    pub fn finish(mut self) -> Vec<u8> {
-        self.align_zero();
-        self.buf
-    }
-    pub fn bytes(&self) -> &[u8] {
-        &self.buf
-    }
-}
-
-/// Remove emulation-prevention bytes (`00 00 03` → `00 00`) from a NAL payload.
-pub fn unescape_rbsp(data: &[u8]) -> Vec<u8> {
-    let mut out = Vec::with_capacity(data.len());
-    let mut zeros = 0;
-    for &b in data {
-        if zeros >= 2 && b == 3 {
-            zeros = 0;
-            continue;
-        }
-        out.push(b);
-        zeros = if b == 0 { zeros + 1 } else { 0 };
-    }
-    out
-}
-
-/// Insert emulation-prevention bytes so no `00 00 0x` (x ≤ 3) sequence appears.
-pub fn escape_rbsp(data: &[u8]) -> Vec<u8> {
-    let mut out = Vec::with_capacity(data.len() + data.len() / 64);
-    let mut zeros = 0;
-    for &b in data {
-        if zeros >= 2 && b <= 3 {
-            out.push(3);
-            zeros = 0;
-        }
-        out.push(b);
-        zeros = if b == 0 { zeros + 1 } else { 0 };
-    }
-    out
-}
-
-/// Split an Annex-B byte stream (start codes `00 00 01` / `00 00 00 01`) into NAL units (escaped payloads).
-pub fn annexb_nals(data: &[u8]) -> Vec<&[u8]> {
-    let mut starts = Vec::new();
-    let mut i = 0;
-    while i + 3 <= data.len() {
-        if data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 1 {
-            starts.push(i + 3);
-            i += 3;
-        } else {
-            i += 1;
-        }
-    }
-    let mut out = Vec::with_capacity(starts.len());
-    for (k, &s) in starts.iter().enumerate() {
-        let mut e = if k + 1 < starts.len() { starts[k + 1] - 3 } else { data.len() };
-        // trim trailing zero bytes (part of a 4-byte start code or trailing_zero_8bits)
-        while e > s && data[e - 1] == 0 {
-            e -= 1;
-        }
-        if e > s {
-            out.push(&data[s..e]);
-        }
-    }
-    out
-}
-
-/// Split a length-prefixed sample (AVCC/HVCC, `length_size` 1..=4 bytes, as the 2-bit `lengthSizeMinusOne` allows) into NAL units.
-pub fn length_prefixed_nals(data: &[u8], length_size: usize) -> Result<Vec<&[u8]>> {
-    if !(1..=4).contains(&length_size) {
-        return Err(BitError::InvalidLengthSize);
-    }
-    let mut out = Vec::new();
-    let mut i = 0;
-    while i < data.len() {
-        if length_size > data.len() - i {
-            return Err(BitError::Eof);
-        }
-        let mut len = 0usize;
-        for k in 0..length_size {
-            len = (len << 8) | data[i + k] as usize;
-        }
-        i += length_size;
-        if len > data.len() - i {
-            return Err(BitError::Eof);
-        }
-        out.push(&data[i..i + len]);
-        i += len;
-    }
-    Ok(out)
-}
-
-/// CRC-32 (IEEE, reflected) — used by containers (e.g. Matroska CRC-32 elements, PNG).
-pub fn crc32(data: &[u8]) -> u32 {
-    let mut crc = 0xFFFF_FFFFu32;
-    for &b in data {
-        crc ^= b as u32;
-        for _ in 0..8 {
-            crc = if crc & 1 != 0 { (crc >> 1) ^ 0xEDB8_8320 } else { crc >> 1 };
-        }
-    }
-    !crc
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use proptest::prelude::*;
-
-    #[test]
-    fn read_ue_plus_rejects_overflow() {
-        let mut w = BitWriter::new();
-        w.write_ue(7);
-        w.write_ue(u32::MAX);
-        w.rbsp_trailing();
-        let b = w.finish();
-        let mut r = BitReader::new(&b);
-        assert_eq!(r.read_ue_plus(1).unwrap(), 8);
-        assert!(r.read_ue_plus(1).is_err());
-    }
-
-    #[test]
-    fn signed_exp_golomb_extremes() {
-        let mut w = BitWriter::new();
-        for v in [i32::MAX, i32::MIN + 1, i32::MIN] {
-            w.write_se(v);
-        }
-        w.rbsp_trailing();
-        let b = w.finish();
-        let mut r = BitReader::new(&b);
-        assert_eq!(r.read_se().unwrap(), i32::MAX);
-        assert_eq!(r.read_se().unwrap(), i32::MIN + 1);
-        assert_eq!(r.read_se(), Err(BitError::InvalidExpGolomb));
-        // ue code 0xFFFF_FFFF maps to +2^31, which must not wrap to a negative i32.
-        let mut w = BitWriter::new();
-        w.write_ue(u32::MAX);
-        w.rbsp_trailing();
-        let b = w.finish();
-        assert_eq!(BitReader::new(&b).read_se(), Err(BitError::InvalidExpGolomb));
-    }
-
-    #[test]
-    fn length_prefixed_rejects_bad_width_and_oversized_length() {
-        assert_eq!(length_prefixed_nals(&[1, 2, 3, 4, 5, 6], 5), Err(BitError::InvalidLengthSize));
-        assert_eq!(length_prefixed_nals(&[1, 2, 3], 0), Err(BitError::InvalidLengthSize));
-        assert_eq!(length_prefixed_nals(&[0, 0, 1, 7], 3).unwrap(), vec![&[7u8][..]]);
-        assert_eq!(length_prefixed_nals(&[0xFF, 0xFF, 0xFF, 0xFF, 1], 4), Err(BitError::Eof));
-        assert_eq!(length_prefixed_nals(&[0, 0, 0, 1, 9], 4).unwrap(), vec![&[9u8][..]]);
-    }
-
-    #[test]
-    fn reads_bits() {
-        let d = [0b1010_1100, 0b0101_0011];
-        let mut r = BitReader::new(&d);
-        assert_eq!(r.read_bits(1).unwrap(), 1);
-        assert_eq!(r.read_bits(3).unwrap(), 0b010);
-        assert_eq!(r.read_bits(8).unwrap(), 0b1100_0101);
-        assert_eq!(r.bits_left(), 4);
-        assert_eq!(r.read_bits(5), Err(BitError::Eof));
-    }
-
-    #[test]
-    fn exp_golomb_known() {
-        // 1 | 010 | 011 | 00100 | 00101 -> 0,1,2,3,4
-        let mut w = BitWriter::new();
-        for v in 0..5 {
-            w.write_ue(v);
-        }
-        let b = w.finish();
-        let mut r = BitReader::new(&b);
-        for v in 0..5 {
-            assert_eq!(r.read_ue().unwrap(), v);
-        }
-        let mut w = BitWriter::new();
-        for v in [0, 1, -1, 2, -2, 1000, -1000] {
-            w.write_se(v);
-        }
-        let b = w.finish();
-        let mut r = BitReader::new(&b);
-        for v in [0, 1, -1, 2, -2, 1000, -1000] {
-            assert_eq!(r.read_se().unwrap(), v);
-        }
-    }
-
-    #[test]
-    fn emulation_prevention() {
-        let raw = [0, 0, 1, 0, 0, 0, 5, 0, 0, 3];
-        let esc = escape_rbsp(&raw);
-        assert_eq!(esc, vec![0, 0, 3, 1, 0, 0, 3, 0, 5, 0, 0, 3, 3]);
-        assert_eq!(unescape_rbsp(&esc), raw);
-    }
-
-    #[test]
-    fn annexb_split() {
-        let s = [0, 0, 0, 1, 0x67, 1, 2, 0, 0, 1, 0x68, 3, 0, 0, 0, 1, 0x65, 9, 9];
-        let n = annexb_nals(&s);
-        assert_eq!(n, vec![&[0x67, 1, 2][..], &[0x68, 3][..], &[0x65, 9, 9][..]]);
-        let l = [0, 0, 0, 2, 0x67, 1, 0, 0, 0, 1, 0x68];
-        assert_eq!(length_prefixed_nals(&l, 4).unwrap(), vec![&[0x67, 1][..], &[0x68][..]]);
-    }
-
-    #[test]
-    fn more_rbsp() {
-        let d = [0b1100_0000];
-        let mut r = BitReader::new(&d);
-        assert!(r.more_rbsp_data());
-        r.read_bit().unwrap();
-        assert!(!r.more_rbsp_data());
-    }
-
-    #[test]
-    fn crc() {
-        assert_eq!(crc32(b"123456789"), 0xCBF4_3926);
-    }
-
-    proptest! {
-        #[test]
-        fn roundtrip(vals in proptest::collection::vec((0u32..u32::MAX, 1u32..=32), 0..200), ues in proptest::collection::vec(0u32..u32::MAX - 1, 0..50)) {
-            let mut w = BitWriter::new();
-            for &(v, n) in &vals { w.write_bits(v, n); }
-            for &u in &ues { w.write_ue(u); }
-            let b = w.finish();
-            let mut r = BitReader::new(&b);
-            for &(v, n) in &vals {
-                let mask = if n == 32 { u32::MAX } else { (1 << n) - 1 };
-                prop_assert_eq!(r.read_bits(n).unwrap(), v & mask);
-            }
-            for &u in &ues { prop_assert_eq!(r.read_ue().unwrap(), u); }
-        }
-
-        #[test]
-        fn escape_roundtrip(data in proptest::collection::vec(0u8..4, 0..300)) {
-            let e = escape_rbsp(&data);
-            prop_assert_eq!(unescape_rbsp(&e), data);
-            for w in e.windows(3) { prop_assert!(!(w[0] == 0 && w[1] == 0 && w[2] < 3)); }
-        }
-    }
-}
@@ -35,7 +35,7 @@ impl Rgba {
    /// `RRGGBB` or `#RRGGBB` (also `RRGGBBAA`).
    pub fn from_hex(s: &str) -> Option<Self> {
        let s = s.trim().trim_start_matches('#');
-        if !s.is_ascii() {
+        if !s.bytes().all(|b| b.is_ascii_hexdigit()) {
            return None;
        }
        let byte = |i: usize| s.get(i..i + 2).and_then(|h| u8::from_str_radix(h, 16).ok());
@@ -519,6 +519,14 @@ pub fn preset(name: &str) -> Option<Rgba> {
 mod tests {
    use super::*;

+    #[test]
+    fn from_hex_rejects_signs() {
+        assert_eq!(Rgba::from_hex("+12345"), None);
+        assert_eq!(Rgba::from_hex("#+1+2+3"), None);
+        assert_eq!(Rgba::from_hex("+1+2+3+4"), None);
+        assert_eq!(Rgba::from_hex("+12"), None);
+    }
+
    #[test]
    fn hex_roundtrip() {
        assert_eq!(Rgba::from_hex("#156082"), Some(Rgba::rgb(0x15, 0x60, 0x82)));
@@ -25,6 +25,7 @@ i_overlay = { workspace = true }
 thiserror = { workspace = true }
 log = { workspace = true }
 image = { workspace = true }
+chrono = { workspace = true }

 [dev-dependencies]
 deckcraft-anim = { workspace = true }
@@ -525,4 +525,46 @@ mod tests {
        s.execute("animation.painterApply", &json!({"ids": [id3]})).unwrap();
        assert!(s.anim_painter.is_some());
    }
+
+    fn setup_triggers() -> (Session, [u64; 4]) {
+        let mut s = Session::with_new();
+        let mut ids = [0u64; 4];
+        for (slot, x) in ids.iter_mut().zip([10.0, 150.0, 300.0, 450.0]) {
+            let r = s.execute("shape.insert", &json!({"preset": "rect", "rect": [x, 10.0, 100.0, 100.0]})).unwrap();
+            *slot = r.get("id").unwrap().as_u64().unwrap();
+        }
+        (s, ids)
+    }
+
+    fn triggers(s: &Session) -> Vec<Option<deckcraft_model::ShapeId>> {
+        s.doc().unwrap().current_slide().unwrap().animations.iter().map(|x| x.trigger).collect()
+    }
+
+    #[test]
+    fn deleting_a_trigger_shape_clears_the_trigger() {
+        let (mut s, [a, b, c, d]) = setup_triggers();
+        let id = |v: u64| Some(deckcraft_model::ShapeId(v as u32));
+        s.execute("animation.add", &json!({"effect": "fade", "ids": [a]})).unwrap();
+        s.execute("animation.add", &json!({"effect": "fade", "ids": [d]})).unwrap();
+        s.execute("animation.timing", &json!({"index": 0, "trigger": b})).unwrap();
+        s.execute("animation.timing", &json!({"index": 1, "trigger": c})).unwrap();
+        assert_eq!(triggers(&s), vec![id(b), id(c)]);
+
+        s.execute("edit.delete", &json!({"ids": [b]})).unwrap();
+        assert_eq!(triggers(&s), vec![None, id(c)], "only the deleted trigger is cleared");
+        assert_eq!(s.doc().unwrap().current_slide().unwrap().animations.len(), 2, "the animated shapes keep their effects");
+    }
+
+    #[test]
+    fn deleting_a_group_clears_triggers_of_its_children() {
+        let (mut s, [a, b, c, _]) = setup_triggers();
+        let g = s.execute("arrange.group", &json!({"ids": [b, c]})).unwrap().get("id").unwrap().as_u64().unwrap();
+        s.execute("animation.add", &json!({"effect": "fade", "ids": [a]})).unwrap();
+        s.execute("animation.timing", &json!({"index": 0, "trigger": b})).unwrap();
+        assert_eq!(triggers(&s), vec![Some(deckcraft_model::ShapeId(b as u32))]);
+
+        s.execute("edit.delete", &json!({"ids": [g]})).unwrap();
+        assert_eq!(triggers(&s), vec![None], "the trigger was inside the deleted group");
+        assert_eq!(s.doc().unwrap().current_slide().unwrap().animations.len(), 1);
+    }
 }
@@ -208,7 +208,7 @@ fn group(s: &mut Session, p: &Value) -> Result<Value> {
 }

 /// A child's xfrm in slide space, given its group.
-pub(crate) fn child_to_parent(group: &Xfrm, ch: &Xfrm, c: &Xfrm) -> Xfrm {
+pub fn child_to_parent(group: &Xfrm, ch: &Xfrm, c: &Xfrm) -> Xfrm {
    let sx = if ch.w.abs() > 1e-9 { group.w / ch.w } else { 1.0 };
    let sy = if ch.h.abs() > 1e-9 { group.h / ch.h } else { 1.0 };
    let a = deckcraft_geom::group_child_affine(group, Rect::new(ch.x, ch.y, ch.x + ch.w, ch.y + ch.h));
@@ -1,6 +1,7 @@
 //! Design tab and masters: themes, colours, fonts, backgrounds, slide size, header & footer,
 //! Slide Master view.

+use std::collections::BTreeSet;
 use std::sync::Arc;

 use deckcraft_geom::Size;
@@ -592,6 +593,11 @@ fn background_of(doc: &Presentation, sel: &crate::Selection, index: Option<usize
    }
 }

+fn used_master_indices(doc: &Presentation) -> BTreeSet<usize> {
+    let fallback = (!doc.masters.is_empty()).then_some(0);
+    doc.slides.iter().filter_map(|sl| doc.masters.iter().position(|m| m.layout(sl.layout).is_some()).or(fallback)).collect()
+}
+
 fn backgrounds_already(doc: &Presentation, sel: &crate::Selection, index: Option<usize>, all: bool, bg: &Option<Background>) -> bool {
    match sel.target {
        Target::Master { master } => doc.masters.get(master).is_some_and(|m| m.background == *bg),
@@ -599,7 +605,16 @@ fn backgrounds_already(doc: &Presentation, sel: &crate::Selection, index: Option
        t @ (Target::Handout | Target::NotesMaster) => crate::page_master(doc, t).is_some_and(|m| m.background == *bg),
        Target::Slides => {
            let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
-            !list.is_empty() && list.iter().all(|i| doc.slides.get(*i).is_some_and(|sl| sl.background == *bg))
+            let slides_match = !list.is_empty() && list.iter().all(|i| doc.slides.get(*i).is_some_and(|sl| sl.background == *bg));
+            if all && bg.is_some() {
+                let masters = used_master_indices(doc);
+                let masters_match = !masters.is_empty() && masters.iter().all(|&idx| doc.masters.get(idx).is_some_and(|m| m.background == *bg));
+                let layouts_match = !masters.is_empty()
+                    && masters.iter().all(|&idx| doc.masters.get(idx).is_some_and(|m| m.layouts.iter().all(|l| l.background.is_none())));
+                slides_match && masters_match && layouts_match
+            } else {
+                slides_match
+            }
        }
    }
 }
@@ -622,6 +637,17 @@ fn write_background(doc: &mut Presentation, sel: &crate::Selection, index: Optio
            }
        }
        Target::Slides => {
+            if all && bg.is_some() {
+                for idx in used_master_indices(doc) {
+                    if let Some(m) = doc.masters.get_mut(idx) {
+                        let m = Arc::make_mut(m);
+                        m.background = bg.clone();
+                        for l in &mut m.layouts {
+                            l.background = None;
+                        }
+                    }
+                }
+            }
            let list: Vec<usize> = if all { (0..doc.slides.len()).collect() } else { vec![index.unwrap_or(sel.slide)] };
            for i in list {
                if let Some(sl) = doc.slides.get_mut(i) {
@@ -639,7 +665,14 @@ fn copy_slide_background(s: &mut Session) -> Result<Value> {
            return Err(bad("design.background", "copy applies to slides"));
        }
        let bg = st.doc.slides.get(st.selection.slide).and_then(|sl| sl.background.clone());
-        if st.doc.slides.iter().all(|sl| sl.background == bg) {
+        let slides_match = st.doc.slides.iter().all(|sl| sl.background == bg);
+        let masters_match = if bg.is_some() {
+            let masters = used_master_indices(&st.doc);
+            !masters.is_empty() && masters.iter().all(|&idx| st.doc.masters.get(idx).is_some_and(|m| m.background == bg))
+        } else {
+            true
+        };
+        if slides_match && masters_match {
            return ok();
        }
        bg
@@ -943,18 +976,21 @@ pub fn date_field_text(kind: &str) -> String {
    DateTime::now_local().and_then(|now| field_text(kind, None, now)).unwrap_or_default()
 }

-/// Days since 1970-01-01 → (year, month, day) (Howard Hinnant's algorithm).
+/// Days since 1970-01-01 → (year, month, day), exact for every `i64`.
 pub fn civil(z: i64) -> (i64, u32, u32) {
-    let z = z + 719_468;
-    let era = z.div_euclid(146_097);
-    let doe = z.rem_euclid(146_097);
-    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
-    let y = yoe + era * 400;
-    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-    let mp = (5 * doy + 2) / 153;
-    let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
-    let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
-    (if m <= 2 { y + 1 } else { y }, m, d)
+    use chrono::Datelike;
+    // `NaiveDate` covers only about ±262143 years, and the Gregorian calendar repeats every 400
+    // years (146_097 days). chrono converts the day within its cycle and whole cycles go back
+    // into the year (an i128 for i64::MAX/MIN). 1970-01-01 is `num_days_from_ce` 719_163, and
+    // 0..146_097 days from it always fits.
+    let (cycles, rest) = (z.div_euclid(146_097), z.rem_euclid(146_097));
+    match i32::try_from(rest + 719_163).ok().and_then(chrono::NaiveDate::from_num_days_from_ce_opt) {
+        Some(d) => {
+            let y = i128::from(d.year()) + i128::from(cycles) * 400;
+            (i64::try_from(y).unwrap_or(if y < 0 { i64::MIN } else { i64::MAX }), d.month(), d.day())
+        }
+        None => (1970, 1, 1),
+    }
 }

 fn master_view(s: &mut Session, p: &Value) -> Result<Value> {
@@ -1456,6 +1492,8 @@ fn slide_number_paragraph() -> deckcraft_model::Paragraph {

 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+
    use deckcraft_color::SchemeSlot;
    use deckcraft_model::style::PictureMode;
    use deckcraft_model::theme::{FontScheme, ScriptFont, builtin_color_schemes, builtin_font_schemes};
@@ -1495,6 +1533,11 @@ mod tests {
    fn civil_dates() {
        assert_eq!(super::civil(0), (1970, 1, 1));
        assert_eq!(super::civil(20_734), (2026, 10, 8));
+        // Past `NaiveDate`'s range the 400-year cycles carry the year, exactly, up to the extremes.
+        assert_eq!(super::civil(95_026_602), (262_144, 1, 1));
+        assert_eq!(super::civil(-96_465_964), (-262_145, 3, 1));
+        assert_eq!(super::civil(i64::MAX), (25_252_734_927_768_524, 7, 27));
+        assert_eq!(super::civil(i64::MIN), (-25_252_734_927_764_585, 6, 7));
    }

    #[test]
@@ -1727,6 +1770,187 @@ mod tests {
        s.execute("design.background", &json!({"copy": true})).unwrap();
        assert_eq!(undo_len(&s), n + 1, "copying an already shared background is not an undo step");
    }
+
+    #[test]
+    fn background_all_applies_to_master_and_new_slides_inherit() {
+        let mut s = Session::with_new();
+        s.execute("file.new", &json!({"theme": "Nocturne"})).unwrap();
+        let s0 = s.execute("slide.inspect", &json!({"index": 0})).unwrap();
+        assert_eq!(s0["background"], "#121826");
+
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"color": "#0D0D0D", "all": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1);
+
+        // Idempotency: re-applying the same background to all is a no-op (no extra undo step)
+        s.execute("design.background", &json!({"color": "#0D0D0D", "all": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "re-applying already applied background is not an undo step");
+
+        // Slide 0 has new background, master has new background, layouts cleared
+        let doc = &s.doc().unwrap().doc;
+        assert!(matches!(doc.slides[0].background, Some(Background::Fill { .. })));
+        assert_eq!(doc.masters[0].background, doc.slides[0].background);
+        for l in &doc.masters[0].layouts {
+            assert!(l.background.is_none());
+        }
+
+        // Newly added slides inherit the master background (fixes #891)
+        s.execute("slide.new", &json!({"layout": "titleAndContent", "title": "new"})).unwrap();
+        let s0_after = s.execute("slide.inspect", &json!({"index": 0})).unwrap();
+        let s1_after = s.execute("slide.inspect", &json!({"index": 1})).unwrap();
+        assert_eq!(s0_after["background"], "#0D0D0D");
+        assert_eq!(s1_after["background"], "#0D0D0D");
+
+        // Undo restores previous slide and master backgrounds
+        s.execute("edit.undo", &json!({})).unwrap(); // undos slide.new
+        assert_eq!(s.doc().unwrap().doc.slides.len(), 1);
+        s.execute("edit.undo", &json!({})).unwrap(); // undos design.background
+        let s0_reverted = s.execute("slide.inspect", &json!({"index": 0})).unwrap();
+        assert_eq!(s0_reverted["background"], "#121826");
+    }
+
+    #[test]
+    fn background_copy_from_slide_following_master_preserves_master_and_layout_backgrounds() {
+        let mut s = Session::with_new();
+        s.execute("file.new", &json!({"theme": "Nocturne"})).unwrap();
+        s.execute("slide.new", &json!({"layout": "titleAndContent"})).unwrap();
+
+        let custom_layout_bg = Background::Fill { fill: Fill::solid(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(0x22, 0x22, 0x22))) };
+        s.edit(|doc, _| {
+            let m = Arc::make_mut(&mut doc.masters[0]);
+            m.layouts[0].background = Some(custom_layout_bg.clone());
+            Ok(())
+        })
+        .unwrap();
+
+        // Slide 0 follows master (background: None)
+        assert!(s.doc().unwrap().doc.slides[0].background.is_none());
+        // Give Slide 1 an explicit override
+        s.execute("design.background", &json!({"color": "#FF0000", "index": 1})).unwrap();
+        assert!(s.doc().unwrap().doc.slides[1].background.is_some());
+
+        let orig_master_bg = s.doc().unwrap().doc.masters[0].background.clone();
+        assert!(orig_master_bg.is_some());
+
+        // Select slide 0 (which follows master) and apply copy to all
+        s.execute("slide.go", &json!({"index": 0})).unwrap();
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"copy": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1);
+
+        // Slide 1 has been reset to None (follows master), slide 0 remains None
+        let doc = &s.doc().unwrap().doc;
+        assert!(doc.slides[0].background.is_none());
+        assert!(doc.slides[1].background.is_none());
+
+        // Master and layout backgrounds survived!
+        assert_eq!(doc.masters[0].background, orig_master_bg);
+        assert_eq!(doc.masters[0].layouts[0].background, Some(custom_layout_bg));
+
+        // Idempotency: re-applying copy is a no-op
+        s.execute("design.background", &json!({"copy": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "re-copying when already matching is a no-op");
+    }
+
+    #[test]
+    fn background_reset_all_preserves_master_and_layout_backgrounds() {
+        let mut s = Session::with_new();
+        s.execute("file.new", &json!({"theme": "Nocturne"})).unwrap();
+        s.execute("slide.new", &json!({"layout": "titleAndContent"})).unwrap();
+
+        let custom_layout_bg = Background::Fill { fill: Fill::solid(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(0x33, 0x33, 0x33))) };
+        s.edit(|doc, _| {
+            let m = Arc::make_mut(&mut doc.masters[0]);
+            m.layouts[0].background = Some(custom_layout_bg.clone());
+            Ok(())
+        })
+        .unwrap();
+
+        let orig_master_bg = s.doc().unwrap().doc.masters[0].background.clone();
+        assert!(orig_master_bg.is_some());
+
+        // Set explicit backgrounds on both slides individually (master remains untouched)
+        s.execute("design.background", &json!({"color": "#0D0D0D", "index": 0})).unwrap();
+        s.execute("design.background", &json!({"color": "#0D0D0D", "index": 1})).unwrap();
+        assert!(s.doc().unwrap().doc.slides[0].background.is_some());
+        assert!(s.doc().unwrap().doc.slides[1].background.is_some());
+
+        // Now perform reset with all
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"reset": true, "all": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1);
+
+        // Slides reset to None to follow master
+        let doc = &s.doc().unwrap().doc;
+        assert!(doc.slides[0].background.is_none());
+        assert!(doc.slides[1].background.is_none());
+
+        // Master and layout backgrounds survived!
+        assert_eq!(doc.masters[0].background, orig_master_bg);
+        assert_eq!(doc.masters[0].layouts[0].background, Some(custom_layout_bg));
+
+        // Idempotency: re-running reset all is a no-op
+        s.execute("design.background", &json!({"reset": true, "all": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "re-resetting when already reset is a no-op");
+    }
+
+    #[test]
+    fn background_all_only_touches_used_masters() {
+        let mut s = Session::with_new();
+        s.execute("file.new", &json!({"theme": "Nocturne"})).unwrap();
+
+        // Add a second master to presentation
+        let second_master_bg = Background::Fill { fill: Fill::solid(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(0x55, 0x55, 0x55))) };
+        s.edit(|doc, _| {
+            let mut m2 = (*doc.masters[0]).clone();
+            m2.id = deckcraft_model::MasterId(999);
+            m2.background = Some(second_master_bg.clone());
+            doc.masters.push(Arc::new(m2));
+            Ok(())
+        })
+        .unwrap();
+
+        assert_eq!(s.doc().unwrap().doc.masters.len(), 2);
+        // Slides only use master 0 (default layout)
+        s.execute("design.background", &json!({"color": "#AA0000", "all": true})).unwrap();
+
+        let doc = &s.doc().unwrap().doc;
+        // Master 0 updated
+        assert_eq!(doc.masters[0].background, doc.slides[0].background);
+        // Master 1 preserved!
+        assert_eq!(doc.masters[1].background, Some(second_master_bg));
+    }
+
+    #[test]
+    fn background_all_clears_layout_overrides_even_if_slides_and_master_match() {
+        let mut s = Session::with_new();
+        s.execute("file.new", &json!({"theme": "Nocturne"})).unwrap();
+
+        // Set all slides and master to #AA0000
+        s.execute("design.background", &json!({"color": "#AA0000", "all": true})).unwrap();
+        assert_eq!(s.doc().unwrap().doc.masters[0].background, s.doc().unwrap().doc.slides[0].background);
+
+        // Add a layout override on layout 0
+        let custom_bg = Background::Fill { fill: Fill::solid(deckcraft_model::ColorRef::rgb(deckcraft_color::Rgba::rgb(0x12, 0x34, 0x56))) };
+        s.edit(|doc, _| {
+            let m = Arc::make_mut(&mut doc.masters[0]);
+            m.layouts[0].background = Some(custom_bg);
+            Ok(())
+        })
+        .unwrap();
+
+        // Re-run Apply to All with #AA0000. Must not be skipped as no-op; must clear layout override.
+        let n = undo_len(&s);
+        s.execute("design.background", &json!({"color": "#AA0000", "all": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "should execute and clear layout override, not treat as no-op");
+
+        let doc = &s.doc().unwrap().doc;
+        assert!(doc.masters[0].layouts[0].background.is_none());
+
+        // Now that layout override is cleared, repeating is an actual no-op
+        s.execute("design.background", &json!({"color": "#AA0000", "all": true})).unwrap();
+        assert_eq!(undo_len(&s), n + 1, "now it is truly a no-op");
+    }
 }

 #[cfg(test)]
@@ -51,6 +51,8 @@ fn restore(s: &mut Session, redo: bool) -> Result<Value> {
    st.doc = e.doc;
    st.selection = e.selection;
    st.interaction = None;
+    // A later shape can get an undone copy's id: Duplicate starts over with the usual offset.
+    st.last_duplicate = None;
    st.revision += 1;
    Ok(json!({"label": e.label}))
 }
@@ -534,15 +536,31 @@ fn paste_text(s: &mut Session, p: &Value) -> Result<Value> {
 fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
    let ids = targets(s, p)?;
    let off = s.prefs.duplicate_offset;
-    s.edit(|doc, sel| {
+    let last = s.doc()?.last_duplicate.clone();
+    let (new_ids, made) = s.edit(|doc, sel| {
        let list = super::current_shapes(doc, sel).cloned().unwrap_or_default();
        let mut copies: Vec<Shape> = list.iter().filter(|x| ids.contains(&x.id)).cloned().collect();
+        let sources: Vec<ShapeId> = copies.iter().map(|c| c.id).collect();
        let boxes: Vec<_> = copies.iter().map(|c| xfrm_of(doc, sel, c)).collect();
+        // Duplicating the copies of the last Duplicate again repeats how far they were moved
+        // since (#966); anything else gets the usual offset.
+        let (dx, dy) = last
+            .filter(|(slide, target, pairs)| {
+                *slide == sel.slide && *target == sel.target && pairs.len() == sources.len() && pairs.iter().all(|(_, c)| sources.contains(c))
+            })
+            .and_then(|(_, _, pairs)| {
+                let (src, copy) = pairs.first()?;
+                let a = xfrm_of(doc, sel, list.iter().find(|x| x.id == *src)?);
+                let b = xfrm_of(doc, sel, list.iter().find(|x| x.id == *copy)?);
+                let d = (b.x - a.x, b.y - a.y);
+                (d.0.is_finite() && d.1.is_finite()).then_some(d)
+            })
+            .unwrap_or((off, off));
        reid("edit.duplicate", doc, &mut copies)?;
        for (c, b) in copies.iter_mut().zip(boxes) {
            let mut x = b;
-            x.x += off;
-            x.y += off;
+            x.x += dx;
+            x.y += dy;
            c.xfrm = Some(x);
            if sel.target == crate::Target::Slides {
                c.ph = None;
@@ -555,8 +573,11 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
        let shapes = crate::shapes_mut(doc, sel).ok_or_else(|| bad("edit.duplicate", "no slide"))?;
        shapes.extend(copies);
        sel.shapes = new_ids.clone();
-        Ok(json!({"ids": new_ids}))
-    })
+        let made = (sel.slide, sel.target, sources.into_iter().zip(new_ids.iter().copied()).collect());
+        Ok((new_ids, made))
+    })?;
+    s.doc_mut()?.last_duplicate = Some(made);
+    Ok(json!({"ids": new_ids}))
 }

 fn delete(s: &mut Session, p: &Value) -> Result<Value> {
@@ -572,12 +593,24 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
    }
    s.edit(|doc, sel| {
        let shapes = crate::shapes_mut(doc, sel).ok_or_else(|| bad("edit.delete", "no slide"))?;
+        let mut before = Vec::new();
+        deckcraft_model::walk(shapes, &mut |s, _| before.push(s.id));
        let n = remove_shapes(shapes, &ids);
+        // Everything that is gone: the given ids plus group descendants and emptied groups.
+        let mut left = Vec::new();
+        deckcraft_model::walk(shapes, &mut |s, _| left.push(s.id));
+        let mut gone = ids.clone();
+        gone.extend(before.into_iter().filter(|i| !left.contains(i)));
        // Animations of deleted shapes go too.
        if sel.target == crate::Target::Slides
            && let Some(sl) = doc.slides.get_mut(sel.slide)
        {
-            Arc::make_mut(sl).animations.retain(|a| !ids.contains(&a.shape));
+            let sl = Arc::make_mut(sl);
+            sl.animations.retain(|a| !gone.contains(&a.shape));
+            // Effects triggered by a deleted shape fall back to the main sequence.
+            for a in sl.animations.iter_mut().filter(|a| a.trigger.is_some_and(|t| gone.contains(&t))) {
+                a.trigger = None;
+            }
        }
        sel.shapes.retain(|i| !ids.contains(i));
        sel.text = None;
@@ -1,6 +1,10 @@
 //! File menu: new, open, save, export, close, properties.

-use deckcraft_model::{Presentation, defaults};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use deckcraft_media::MediaInfo;
+use deckcraft_model::{MediaId, MediaItem, Presentation, Shape, ShapeKind, defaults};
 use serde_json::{Value, json};

 use super::*;
@@ -156,6 +160,7 @@ fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec<String>)> {
    if deckcraft_pptx::sniff(bytes) {
        let (mut p, lost_slides) = deckcraft_pptx::import_checked(bytes).map_err(|e| EngineError::Other(e.to_string()))?;
        deckcraft_format::repair(&mut p);
+        probe_clips(&mut p);
        return Ok((p, lost_slides));
    }
    if deckcraft_pptx::is_encrypted(bytes) {
@@ -178,6 +183,42 @@ fn open_other(name: &str, bytes: &[u8]) -> Result<(Presentation, Vec<String>)> {
    Err(EngineError::Other(format!("{name}: not a presentation DeckCraft can read")))
 }

+/// Fill in each audio and video clip's length and picture size from its bytes: a `.pptx` doesn't
+/// store them. Headers only, so opening never decodes a whole audio file.
+fn probe_clips(p: &mut Presentation) {
+    fn rec(shapes: &mut [Shape], media: &[MediaItem], probed: &mut HashMap<MediaId, Option<MediaInfo>>, depth: usize) {
+        if depth > 64 {
+            return;
+        }
+        for s in shapes {
+            if let ShapeKind::Media(m) = &mut s.kind
+                && (m.duration_ms == 0 || m.width == 0 && m.height == 0)
+                && let Some(info) = probed
+                    .entry(m.media)
+                    .or_insert_with(|| media.iter().find(|i| i.id == m.media).and_then(|i| deckcraft_media::probe_headers(&i.data).ok()))
+            {
+                if m.duration_ms == 0 {
+                    m.duration_ms = info.duration_ms.min(u32::MAX as u64) as u32;
+                }
+                if m.width == 0
+                    && m.height == 0
+                    && let Some(v) = &info.video
+                {
+                    (m.width, m.height) = (v.width, v.height);
+                }
+            }
+            if let Some(children) = s.children_mut() {
+                rec(children, media, probed, depth + 1);
+            }
+        }
+    }
+    let mut probed = HashMap::new();
+    // Just read, so no slide is shared yet and `make_mut` doesn't copy.
+    for slide in &mut p.slides {
+        rec(&mut Arc::make_mut(slide).shapes, &p.media, &mut probed, 0);
+    }
+}
+
 pub fn add_opened(s: &mut Session, name: &str, path: Option<String>, p: Presentation) -> usize {
    let title = std::path::Path::new(name).file_stem().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| name.to_string());
    crate::fonts::install_embedded_fonts(&p);
@@ -105,7 +105,7 @@ impl Opts {
 }

 fn para_chars(p: &Paragraph) -> Vec<char> {
-    p.runs.iter().flat_map(|r| r.text.chars()).collect()
+    p.runs.iter().flat_map(|r| r.content().chars()).collect()
 }

 /// Matches that lie wholly in plain text runs (never inside a field, equation or break).
@@ -113,7 +113,7 @@ fn para_matches(p: &Paragraph, o: &Opts) -> Vec<(usize, usize)> {
    let mut spans = vec![];
    let mut off = 0;
    for r in &p.runs {
-        let n = r.text.chars().count();
+        let n = r.char_len();
        spans.push((off, off + n, matches!(r.kind, RunKind::Text)));
        off += n;
    }
@@ -125,7 +125,7 @@ fn splice(p: &mut Paragraph, a: usize, b: usize, with: &str) {
    let mut off = 0;
    let mut placed = false;
    for r in &mut p.runs {
-        let chars: Vec<char> = r.text.chars().collect();
+        let chars: Vec<char> = r.content().chars().collect();
        let (s, e) = (off, off + chars.len());
        off = e;
        if e <= a || s >= b {
@@ -222,6 +222,34 @@ mod tests {
        assert_eq!(opts("cat", false, true).matches(&t), vec![(0, 3), (4, 7)]);
    }

+    fn text_run(t: &str) -> Run {
+        Run { text: t.into(), props: RunProps::default(), kind: RunKind::Text }
+    }
+
+    fn br() -> Run {
+        Run { text: String::new(), props: RunProps::default(), kind: RunKind::Break }
+    }
+
+    #[test]
+    fn a_match_never_spans_a_line_break() {
+        let p = Paragraph { runs: vec![text_run("a"), br(), text_run("b")], ..Default::default() };
+        assert!(para_matches(&p, &opts("ab", true, false)).is_empty());
+    }
+
+    #[test]
+    fn offsets_count_a_line_break_as_one_char() {
+        let p = Paragraph { runs: vec![text_run("ab"), br(), text_run("cd")], ..Default::default() };
+        assert_eq!(para_matches(&p, &opts("cd", true, false)), vec![(3, 5)]);
+    }
+
+    #[test]
+    fn splice_after_a_line_break_keeps_the_break() {
+        let mut p = Paragraph { runs: vec![text_run("ab"), br(), text_run("cd")], ..Default::default() };
+        splice(&mut p, 3, 5, "X");
+        assert_eq!(p.text(), "ab\u{b}X");
+        assert_eq!(p.runs[1].kind, RunKind::Break);
+    }
+
    #[test]
    fn splice_across_runs_keeps_the_first_runs_format() {
        let bold = RunProps { bold: Some(true), ..Default::default() };
@@ -1170,6 +1170,31 @@ pub(crate) fn apply_painted(sh: &mut Shape, p: &Painted) {
    }
 }

+/// The paragraphs the text selection covers whole: it starts at or before their start and
+/// reaches their end. A paragraph the selection only touches the start of (it ends at offset
+/// 0, as after a triple-click) is not covered.
+fn covered_paragraphs(s: &Session) -> Vec<usize> {
+    let Ok(st) = s.doc() else { return vec![] };
+    let Some(t) = &st.selection.text else { return vec![] };
+    let Some(body) = super::text::body_of(st, t) else { return vec![] };
+    let (a, b) = t.ordered();
+    // A hostile selection can point past the body: walk only the paragraphs it has.
+    (a.0..=b.0.min(body.paragraphs.len().saturating_sub(1)))
+        .filter(|&pi| {
+            let Some(para) = body.paragraphs.get(pi) else { return false };
+            let starts = pi > a.0 || a.1 == 0;
+            let ends = if pi < b.0 {
+                true
+            } else if b.0 > a.0 && b.1 == 0 {
+                false
+            } else {
+                b.1 >= para.char_len()
+            };
+            starts && ends
+        })
+        .collect()
+}
+
 fn painter_apply(s: &mut Session, p: &Value) -> Result<Value> {
    let Some((painted, sticky)) = s.painter.clone() else { return Err(bad("format.painterApply", "pick formatting with the Format Painter first")) };
    if !sticky {
@@ -1179,8 +1204,17 @@ fn painter_apply(s: &mut Session, p: &Value) -> Result<Value> {
        if let Some(r) = painted.run.clone() {
            format_run(s, &move |rp| *rp = r.clone())?;
        }
-        if let Some(pp) = painted.para.clone() {
-            format_para(s, &move |para| para.props = pp.clone())?;
+        // Paragraph formatting (bullets, alignment, spacing) goes only onto paragraphs the
+        // selection covers whole; painting part of a bulleted line changes just its text.
+        let covered = covered_paragraphs(s);
+        if let (Some(pp), false) = (painted.para.clone(), covered.is_empty()) {
+            super::text::edit_text(s, |body, _| {
+                for &pi in &covered {
+                    if let Some(para) = body.paragraphs.get_mut(pi) {
+                        para.props = pp.clone();
+                    }
+                }
+            })?;
        }
        return ok();
    }
@@ -84,6 +84,22 @@ fn cover_crop(src: f64, dst: f64) -> [f64; 4] {
    }
 }

+/// The light fill behind the title in the full-bleed idea. Its opacity is an `alpha` transform
+/// (about 220/255), as PPTX stores it, so the fill compares equal after a save and reopen.
+fn band_fill() -> Fill {
+    Fill::solid(deckcraft_model::ColorRef::rgb(Rgba::rgb(255, 255, 255)).with(deckcraft_model::ColorTransform::Alpha(86274)))
+}
+
+/// The band as released versions up to 0.10 stored it (opacity in the colour's own alpha).
+fn legacy_band_fill() -> Fill {
+    Fill::solid(deckcraft_model::ColorRef::rgb(Rgba::rgba(255, 255, 255, 220)))
+}
+
+/// Whether `f` is a Full-bleed band, in the current or the legacy form.
+fn is_band(f: &Fill) -> bool {
+    *f == band_fill() || *f == legacy_band_fill()
+}
+
 /// Apply idea `id` to slide `index` of `doc` (`sel` resolves inherited placeholder boxes).
 pub fn apply_idea(doc: &mut Presentation, sel: &Selection, index: usize, id: &str) -> Result<()> {
    if !ideas_for(doc, index).iter().any(|i| i.0 == id) {
@@ -180,8 +196,13 @@ pub fn apply_idea(doc: &mut Presentation, sel: &Selection, index: usize, id: &st
        let pic = slide.shapes.remove(p);
        slide.shapes.insert(0, pic);
    }
-    if band && let Some(t) = slide.shapes.iter_mut().find(|s| s.ph.as_ref().is_some_and(|p| p.kind.is_title())) {
-        t.fill = Some(Fill::solid(deckcraft_model::ColorRef::rgb(Rgba::rgba(255, 255, 255, 220))));
+    if let Some(t) = slide.shapes.iter_mut().find(|s| !s.hidden && s.ph.as_ref().is_some_and(|p| p.kind.is_title())) {
+        if band {
+            t.fill = Some(band_fill());
+        } else if t.fill.as_ref().is_some_and(is_band) {
+            // The band belongs to full-bleed only: another idea takes it away again.
+            t.fill = None;
+        }
    }
    Ok(())
 }
@@ -314,6 +335,85 @@ mod tests {
        assert!(s.execute("design.applyIdea", &json!({"id": "nope"})).is_err());
    }

+    #[test]
+    fn switching_from_full_bleed_removes_the_title_band() {
+        let mut s = deck(true);
+        s.execute("design.applyIdea", &json!({"id": "fullBleed"})).unwrap();
+        assert_eq!(shape(&s, 500).fill, Some(band_fill()));
+        s.execute("design.applyIdea", &json!({"id": "pictureLeft"})).unwrap();
+        assert!(shape(&s, 500).fill.is_none(), "the band belongs to full-bleed only");
+    }
+
+    #[test]
+    fn the_band_goes_on_the_visible_title_not_a_hidden_one_before_it() {
+        let mut s = deck(true);
+        let st = s.doc_mut().unwrap();
+        let slide = Arc::make_mut(&mut Arc::make_mut(&mut st.doc).slides[0]);
+        let hidden = Shape {
+            id: ShapeId(503),
+            hidden: true,
+            ph: Some(Placeholder { kind: PhType::Title, ..Default::default() }),
+            xfrm: Some(Xfrm::new(50.0, 30.0, 860.0, 90.0)),
+            text: Some(deckcraft_model::text::TextBody::from_text("Old title")),
+            ..Default::default()
+        };
+        slide.shapes.insert(0, hidden);
+        s.execute("design.applyIdea", &json!({"id": "fullBleed"})).unwrap();
+        assert_eq!(shape(&s, 500).fill, Some(band_fill()), "visible title gets the band");
+        assert!(shape(&s, 503).fill.is_none(), "hidden title is untouched");
+        s.execute("design.applyIdea", &json!({"id": "pictureLeft"})).unwrap();
+        assert!(shape(&s, 500).fill.is_none(), "switching clears the visible title's band");
+        assert!(shape(&s, 503).fill.is_none());
+    }
+
+    #[test]
+    fn switching_ideas_removes_the_band_after_a_pptx_round_trip() {
+        let mut s = deck(true);
+        s.execute("design.applyIdea", &json!({"id": "fullBleed"})).unwrap();
+        let bytes = deckcraft_pptx::export(&s.doc().unwrap().doc).unwrap();
+        let back = deckcraft_pptx::import(&bytes).unwrap();
+        s.doc_mut().unwrap().doc = Arc::new(back);
+        let title = s.doc().unwrap().doc.slides[0].shapes.iter().position(|x| x.ph.as_ref().is_some_and(|p| p.kind.is_title())).unwrap();
+        let id = s.doc().unwrap().doc.slides[0].shapes[title].id.0;
+        assert_eq!(shape(&s, id).fill, Some(band_fill()), "band survives the save");
+        s.execute("design.applyIdea", &json!({"id": "pictureLeft"})).unwrap();
+        assert!(shape(&s, id).fill.is_none(), "the band is removed after reopening");
+    }
+
+    #[test]
+    fn switching_ideas_removes_a_band_saved_by_earlier_versions() {
+        let mut s = deck(true);
+        let legacy = Fill::solid(deckcraft_model::ColorRef::rgb(Rgba::rgba(255, 255, 255, 220)));
+        let st = s.doc_mut().unwrap();
+        let slide = Arc::make_mut(&mut Arc::make_mut(&mut st.doc).slides[0]);
+        slide.shapes.iter_mut().find(|x| x.id == ShapeId(500)).unwrap().fill = Some(legacy);
+        s.execute("design.applyIdea", &json!({"id": "pictureLeft"})).unwrap();
+        assert!(shape(&s, 500).fill.is_none());
+    }
+
+    #[test]
+    fn a_title_fill_set_by_the_user_survives_other_ideas() {
+        // Set through the command, and set to exactly the band's own fill.
+        let mut s = deck(true);
+        s.execute("shape.fill", &json!({"id": 500, "color": "#ffffff", "transparency": 0.14})).unwrap();
+        let user = shape(&s, 500).fill;
+        assert!(user.is_some());
+        s.execute("design.applyIdea", &json!({"id": "pictureLeft"})).unwrap();
+        assert_eq!(shape(&s, 500).fill, user);
+    }
+
+    #[test]
+    fn full_bleed_twice_keeps_the_band_and_undo_after_switching_brings_it_back() {
+        let mut s = deck(true);
+        s.execute("design.applyIdea", &json!({"id": "fullBleed"})).unwrap();
+        s.execute("design.applyIdea", &json!({"id": "fullBleed"})).unwrap();
+        assert_eq!(shape(&s, 500).fill, Some(band_fill()));
+        s.execute("design.applyIdea", &json!({"id": "framed"})).unwrap();
+        assert!(shape(&s, 500).fill.is_none());
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(shape(&s, 500).fill, Some(band_fill()));
+    }
+
    #[test]
    fn cover_crop_matches_the_box_aspect() {
        let c = cover_crop(2.0, 1.0);
@@ -228,6 +228,21 @@ mod tests {
        assert!(s.execute("media.posterFrame", &json!({})).is_err(), "audio has no poster frame");
    }

+    #[test]
+    fn a_video_reopened_from_pptx_keeps_its_length_and_size() {
+        let mut s = Session::with_new();
+        let clip = include_bytes!("../../../media/tests/fixtures/clip-h264.mp4");
+        s.execute("insert.video", &json!({"name": "clip.mp4", "data": base64_encode(clip)})).expect("insert");
+        let before = s.execute("media.info", &json!({})).expect("info");
+        assert!(before["durationMs"].as_u64().is_some_and(|ms| ms > 0));
+        let saved = s.execute("file.saveBytes", &json!({"format": "pptx"})).expect("save");
+        s.execute("file.openBytes", &json!({"name": "deck.pptx", "data": saved["data"]})).expect("open");
+        let after = s.execute("media.info", &json!({})).expect("info");
+        for key in ["durationMs", "width", "height"] {
+            assert_eq!(after[key], before[key], "{key}");
+        }
+    }
+
    #[test]
    fn media_commands_need_media() {
        let mut s = Session::with_new();
@@ -318,6 +318,14 @@ pub(crate) fn str_param<'a>(p: &'a Value, key: &str) -> Option<&'a str> {
 pub(crate) fn usize_param(p: &Value, key: &str) -> Option<usize> {
    p.get(key).and_then(Value::as_u64).and_then(|v| usize::try_from(v).ok())
 }
+/// An index param: `Ok(None)` when absent (callers may fall back to the selection), `Err` when
+/// present but not a valid index (negative, non-integer), so a bad index never acts on the selection.
+pub(crate) fn opt_usize_param(p: &Value, key: &str, cmd: &str) -> Result<Option<usize>> {
+    match p.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v.as_u64().and_then(|v| usize::try_from(v).ok()).map(Some).ok_or_else(|| bad(cmd, format!("`{key}` is not a valid index: {v}"))),
+    }
+}
 /// A shape id param: `Ok(None)` when absent (callers may fall back to the selection), `Err` when
 /// present but not a valid id (negative, non-integer, beyond `u32`), so a bad id never edits the selection.
 pub(crate) fn id_param(p: &Value, key: &str, cmd: &str) -> Result<Option<ShapeId>> {
@@ -1,8 +1,9 @@
 //! Picture Format ▸ Color: Recolor presets and Set Transparent Color.

 use deckcraft_color::{Rgba, SchemeSlot};
-use deckcraft_model::style::PictureAdjust;
-use deckcraft_model::{ColorRef, ShapeKind};
+use deckcraft_geom::{Affine, Point, Rect, Xfrm};
+use deckcraft_model::style::{PictureAdjust, PictureMode};
+use deckcraft_model::{ColorRef, Shape, ShapeId, ShapeKind};
 use serde_json::{Value, json};

 use super::*;
@@ -27,7 +28,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Set Transparent Color",
            ["Picture Format", "Adjust", "Color"],
            None,
-            "{color: #RRGGBB | none: true, ids?} (pixels of that colour become transparent)",
+            "{color: #RRGGBB | at: [x, y] | none: true, ids?} (pixels of that colour become transparent; `at` takes the colour of the picture's own pixel under that slide point, as a click does in PowerPoint)",
            has_selection,
            transparent_color
        ),
@@ -121,6 +122,15 @@ fn recolor(s: &mut Session, p: &Value) -> Result<Value> {
 }

 fn transparent_color(s: &mut Session, p: &Value) -> Result<Value> {
+    if let Some(at) = p.get("at") {
+        let (id, c) = picture_pixel_at(s, p, at)?;
+        return edit_shapes(s, &json!({"ids": [id]}), "picture.transparentColor", |sh| {
+            if let ShapeKind::Picture { fill } = &mut sh.kind {
+                fill.adjust.clear_color = Some(c);
+            }
+            Ok(())
+        });
+    }
    let c = if bool_or(p, "none", false) {
        None
    } else {
@@ -134,3 +144,97 @@ fn transparent_color(s: &mut Session, p: &Value) -> Result<Value> {
        Ok(())
    })
 }
+
+/// The topmost target picture under slide point `at` and the colour of its own pixel there: the
+/// picture as stored, before corrections and recolouring, so the colour matches the pixels that
+/// `clear_color` is compared with.
+fn picture_pixel_at(s: &Session, p: &Value, at: &Value) -> Result<(ShapeId, Rgba)> {
+    const CMD: &str = "picture.transparentColor";
+    let xy = |i: usize| at.get(i).and_then(Value::as_f64).filter(|v| v.is_finite());
+    let (Some(x), Some(y)) = (xy(0), xy(1)) else {
+        return Err(bad(CMD, "`at` is [x, y] in slide units"));
+    };
+    let mut ids = targets(s, p)?;
+    let st = s.doc()?;
+    let shapes = current_shapes(&st.doc, &st.selection).ok_or_else(|| bad(CMD, "no slide"))?;
+    // Same order as the hit-test: later in the shape list is in front, and a group's children sit
+    // where the group is. The selection order says nothing about what is on top.
+    ids.sort_by_cached_key(|id| std::cmp::Reverse(stack_path(shapes, *id)));
+    for id in ids {
+        let Some((sh, xf, to_slide)) = placed(&st.doc, &st.selection, shapes, id, Affine::IDENTITY, 0) else { continue };
+        let ShapeKind::Picture { fill } = &sh.kind else { continue };
+        // The camera turns the picture where it is drawn, so the click is mapped back through it too.
+        let turn = text::ctx_for(&st.doc, &st.selection).and_then(|c| deckcraft_render::camera_turn(&c, sh, xf.w, xf.h)).unwrap_or(Affine::IDENTITY);
+        let local = (to_slide * turn).inverse() * Point::new(x, y);
+        if !(local.is_finite() && (0.0..=xf.w).contains(&local.x) && (0.0..=xf.h).contains(&local.y)) {
+            continue;
+        }
+        let PictureMode::Stretch { fill_rect: [l, t, r, b] } = fill.mode else {
+            return Err(bad(CMD, "a tiled picture has no single pixel under a point; give `color`"));
+        };
+        let inner = Rect::new(l * xf.w, t * xf.h, xf.w - r * xf.w, xf.h - b * xf.h);
+        let dest = deckcraft_render::crop_dest(inner, fill.crop);
+        let img =
+            st.doc.media(fill.media).and_then(|m| deckcraft_render::decode_image(&m.data)).ok_or_else(|| bad(CMD, "the picture can't be read"))?;
+        let (u, v) = ((local.x - dest.x0) / dest.width(), (local.y - dest.y0) / dest.height());
+        if !((0.0..=1.0).contains(&u) && (0.0..=1.0).contains(&v)) {
+            continue;
+        }
+        let (w, h) = (img.width(), img.height());
+        let px = ((u * f64::from(w)) as u32).min(w.saturating_sub(1));
+        let py = ((v * f64::from(h)) as u32).min(h.saturating_sub(1));
+        let Some(c) = img.get_pixel_checked(px, py) else { continue };
+        // A transparent pixel keeps a colour nobody sees (often black): clearing it would clear
+        // that colour where it is drawn.
+        if c[3] == 0 {
+            return Err(bad(CMD, "that spot of the picture is already transparent"));
+        }
+        return Ok((id, Rgba::rgb(c[0], c[1], c[2])));
+    }
+    Err(bad(CMD, "the point is not on a selected picture"))
+}
+
+/// Where `id` sits in the paint order: its index in each list from the slide down to it. A larger
+/// path is drawn later, so in front.
+fn stack_path(shapes: &[Shape], id: ShapeId) -> Option<Vec<usize>> {
+    for (i, sh) in shapes.iter().enumerate() {
+        if sh.id == id {
+            return Some(vec![i]);
+        }
+        if let ShapeKind::Group { children, .. } = &sh.kind
+            && let Some(mut rest) = stack_path(children, id)
+        {
+            rest.insert(0, i);
+            return Some(rest);
+        }
+    }
+    None
+}
+
+/// Shape `id` among `shapes` (searched into groups), its box, and the map from that box to slide
+/// space.
+fn placed<'a>(
+    doc: &deckcraft_model::Presentation,
+    sel: &crate::Selection,
+    shapes: &'a [Shape],
+    id: ShapeId,
+    to_slide: Affine,
+    depth: usize,
+) -> Option<(&'a Shape, Xfrm, Affine)> {
+    if depth > 64 {
+        return None;
+    }
+    for sh in shapes {
+        let x = xfrm_of(doc, sel, sh);
+        if sh.id == id {
+            return Some((sh, x, to_slide * x.affine()));
+        }
+        if let ShapeKind::Group { children, child } = &sh.kind {
+            let ch = Rect::new(child.x, child.y, child.x + child.w, child.y + child.h);
+            if let Some(found) = placed(doc, sel, children, id, to_slide * deckcraft_geom::group_child_affine(&x, ch), depth + 1) {
+                return Some(found);
+            }
+        }
+    }
+    None
+}
@@ -145,8 +145,13 @@ pub fn html_to_body(html: &str) -> Option<TextBody> {
            continue;
        }
        let end = bytes[i..].iter().position(|c| *c == b'<').map(|n| i + n).unwrap_or(bytes.len());
-        let text = decode_text(&html[i..end]);
+        let mut text = decode_text(&html[i..end]);
        i = end;
+        // A space at the start of a paragraph, or after a space, does not render in HTML.
+        let after_space = paragraphs.last().and_then(|p| p.runs.last()).is_none_or(|r| r.text.ends_with(' '));
+        if after_space {
+            text = text.trim_start_matches(' ').to_string();
+        }
        if text.is_empty() {
            continue;
        }
@@ -155,6 +160,7 @@ pub fn html_to_body(html: &str) -> Option<TextBody> {
    while paragraphs.last().is_some_and(Paragraph::is_empty) && paragraphs.len() > 1 {
        paragraphs.pop();
    }
+    trim_end_space(&mut paragraphs);
    if paragraphs.iter().all(Paragraph::is_empty) {
        return None;
    }
@@ -240,10 +246,19 @@ fn new_para(paragraphs: &mut Vec<Paragraph>) {
        return;
    }
    if paragraphs.last().is_some_and(|p| !p.is_empty()) {
+        trim_end_space(paragraphs);
        paragraphs.push(Paragraph::default());
    }
 }

+/// Whitespace at the end of a paragraph does not render in HTML.
+fn trim_end_space(paragraphs: &mut [Paragraph]) {
+    if let Some(run) = paragraphs.last_mut().and_then(|p| p.runs.last_mut()) {
+        let len = run.text.trim_end_matches(' ').len();
+        run.text.truncate(len);
+    }
+}
+
 fn push_run(paragraphs: &mut [Paragraph], runs: &mut usize, text: String, bold: bool, italic: bool, underline: bool) {
    if *runs >= MAX_RUNS {
        return;
@@ -263,14 +278,32 @@ fn push_run(paragraphs: &mut [Paragraph], runs: &mut usize, text: String, bold:
    *runs += 1;
 }

+/// Text with each run of HTML whitespace (spaces, tabs, line breaks) collapsed to one space.
+fn collapse_space(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut space = false;
+    for c in s.chars() {
+        if matches!(c, ' ' | '\t' | '\n' | '\r') {
+            if !space {
+                out.push(' ');
+            }
+            space = true;
+        } else {
+            out.push(c);
+            space = false;
+        }
+    }
+    out
+}
+
 fn decode_text(raw: &str) -> String {
    let mut out = String::new();
    let mut rest = raw;
    while let Some(at) = rest.find('&') {
-        out.push_str(&rest[..at].replace(['\n', '\r'], ""));
+        out.push_str(&collapse_space(&rest[..at]));
        rest = &rest[at..];
        let Some(end) = rest.find(';') else {
-            out.push_str(&rest.replace(['\n', '\r'], ""));
+            out.push_str(&collapse_space(rest));
            break;
        };
        let entity = &rest[1..end];
@@ -280,7 +313,7 @@ fn decode_text(raw: &str) -> String {
            "gt" => Some('>'),
            "quot" => Some('"'),
            "apos" => Some('\''),
-            "nbsp" => Some(' '),
+            "nbsp" => Some('\u{a0}'),
            _ => entity.strip_prefix('#').and_then(numeric_char),
        };
        if let Some(c) = decoded {
@@ -293,7 +326,7 @@ fn decode_text(raw: &str) -> String {
        }
    }
    if !rest.is_empty() && !rest.starts_with('&') {
-        out.push_str(&rest.replace(['\n', '\r'], ""));
+        out.push_str(&collapse_space(rest));
    }
    out
 }
@@ -371,6 +404,18 @@ mod tests {
        assert!(!same_words(&body.text(), "other"));
    }

+    #[test]
+    fn a_newline_in_html_text_is_a_space() {
+        assert_eq!(decode_text("Hello\nworld"), "Hello world");
+        let body = html_to_body("<p>Hello\r\n  world</p>").unwrap();
+        assert_eq!(body.text(), "Hello world");
+        let body = html_to_body("<p>\n<b>Hello</b>\n<i>world</i>\n</p>\n<p>next</p>").unwrap();
+        assert_eq!(body.text(), "Hello world\nnext");
+        assert!(same_words(&body.text(), "Hello world\nnext"));
+        assert_eq!(body.paragraphs[0].runs[0].props.bold, Some(true));
+        assert_eq!(body.paragraphs[0].runs.last().unwrap().props.italic, Some(true));
+    }
+
    #[test]
    fn a_huge_fragment_is_refused() {
        let html = "x".repeat(MAX_HTML + 1);
@@ -1,6 +1,8 @@
 //! Shape Format: position and size, rotation, flips, geometry, fill, outline, effects, styles,
 //! names and alt text.

+use std::collections::HashMap;
+
 use deckcraft_color::{ColorTransform, Rgba, SchemeSlot};
 use deckcraft_model::style::{Dash, Glow, Gradient, GradientShape, GradientStop, LineEnd, PatternFill, PictureFill, PictureMode, Reflection, Shadow};
 use deckcraft_model::{ColorRef, Effects, Fill, Geom, Line, ShapeStyle};
@@ -85,7 +87,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Shape Fill",
            ["Shape Format", "Shape Styles"],
            None,
-            "{color? | none?: true | gradient?: {stops: [[pos, color]], angle?, kind?: linear|radial} | picture?: base64 | pattern?: {preset, fg, bg} | transparency?: 0..1 | reset?: true, ids?}; pictureProps?: {tile?: bool, offsetX?, offsetY?: pt, scaleX?, scaleY?: 0..10, align?: tl|t|tr|l|ctr|r|bl|b|br, mirror?: none|x|y|xy, stretch?: [l, t, r, b] fractions, rotateWithShape?: bool} adjusts a picture fill",
+            "{color? | none?: true | gradient?: {stops: [[pos, color]], angle?, kind?: linear|radial} | picture?: base64 | pattern?: {preset, fg, bg} | transparency?: 0..1 | reset?: true, ids?}; pictureProps?: {tile?: bool, offsetX?, offsetY?: pt, scaleX?, scaleY?: 0..10, align?: tl|t|tr|l|ctr|r|bl|b|br, mirror?: none|x|y|xy, stretch?: [l, t, r, b] fractions, rotateWithShape?: bool} adjusts a picture fill; a group also formats its members",
            has_selection,
            fill
        ),
@@ -94,7 +96,7 @@ pub fn specs() -> Vec<CommandSpec> {
            "Shape Outline",
            ["Shape Format", "Shape Styles"],
            None,
-            "{color?, none?, width?: pt, dash?: solid|dot|dash|lgDash|dashDot|sysDot|sysDash, cap?: flat|round|square, join?: round|bevel|miter, compound?: single|double|thickThin|thinThick|triple, head?: none|triangle|stealth|diamond|oval|arrow, tail?, headSize?: sm|med|lg, tailSize?, reset?, ids?}",
+            "{color?, none?, width?: pt, dash?: solid|dot|dash|lgDash|dashDot|sysDot|sysDash, cap?: flat|round|square, join?: round|bevel|miter, compound?: single|double|thickThin|thinThick|triple, head?: none|triangle|stealth|diamond|oval|arrow, tail?, headSize?: sm|med|lg, tailSize?, reset?, ids?}; a group also formats its members",
            has_selection,
            line
        ),
@@ -533,6 +535,24 @@ pub(crate) fn gradient_param(v: &Value) -> Option<Gradient> {
    Some(Gradient { tile: [0.0; 4], stops, shape, rotate_with_shape: v.get("rotateWithShape").and_then(Value::as_bool).unwrap_or(true) })
 }

+/// Fill and outline apply to a group's visible members as well as its container. Other edits
+/// (notably geometry) still target only the selected shape. The whole traversal stays in one edit.
+fn edit_group_appearance(s: &mut Session, p: &Value, cmd: &str, f: impl Fn(&mut deckcraft_model::Shape) -> Result<()>) -> Result<Value> {
+    fn apply(sh: &mut deckcraft_model::Shape, depth: usize, f: &dyn Fn(&mut deckcraft_model::Shape) -> Result<()>) -> Result<()> {
+        if depth > 64 {
+            return Ok(());
+        }
+        f(sh)?;
+        if let Some(children) = sh.children_mut() {
+            for child in children {
+                apply(child, depth + 1, f)?;
+            }
+        }
+        Ok(())
+    }
+    edit_shapes(s, p, cmd, |sh| apply(sh, 0, &f))
+}
+
 fn fill(s: &mut Session, p: &Value) -> Result<Value> {
    let new_fill: Option<Option<Fill>> = if bool_or(p, "reset", false) {
        Some(None)
@@ -565,27 +585,26 @@ fn fill(s: &mut Session, p: &Value) -> Result<Value> {
    }
    // Transparency on an inherited (style) fill needs the effective colour.
    let st = s.doc()?;
-    let ctx_fill: Vec<(deckcraft_model::ShapeId, Option<Fill>)> = {
+    let ctx_fill = {
        let ctx = super::text::ctx_for(&st.doc, &st.selection);
-        targets(s, p)?
-            .into_iter()
-            .filter_map(|id| {
-                st.shape(id).map(|sh| {
-                    (
-                        id,
-                        ctx.as_ref().and_then(|c| {
-                            let (f, ph) = deckcraft_model::resolve::fill(c, sh);
-                            f.map(|f| match f {
-                                Fill::Solid { color } => Fill::solid(ColorRef::rgb(c.color(&color, ph))),
-                                other => other,
-                            })
-                        }),
-                    )
-                })
-            })
-            .collect()
+        let mut fills = HashMap::new();
+        for id in targets(s, p)? {
+            if let Some(sh) = st.shape(id) {
+                deckcraft_model::walk(std::slice::from_ref(sh), &mut |sh, _| {
+                    let fill = ctx.as_ref().and_then(|c| {
+                        let (f, ph) = deckcraft_model::resolve::fill(c, sh);
+                        f.map(|f| match f {
+                            Fill::Solid { color } => Fill::solid(ColorRef::rgb(c.color(&color, ph))),
+                            other => other,
+                        })
+                    });
+                    fills.insert(sh.id, fill);
+                });
+            }
+        }
+        fills
    };
-    edit_shapes(s, p, "shape.fill", |sh| {
+    edit_group_appearance(s, p, "shape.fill", |sh| {
        if let Some(f) = &new_fill {
            sh.fill.clone_from(f);
        }
@@ -598,7 +617,7 @@ fn fill(s: &mut Session, p: &Value) -> Result<Value> {
            return Ok(());
        }
        if let Some(t) = transparency {
-            let base = sh.fill.clone().or_else(|| ctx_fill.iter().find(|(i, _)| *i == sh.id).and_then(|(_, f)| f.clone()));
+            let base = sh.fill.clone().or_else(|| ctx_fill.get(&sh.id).cloned().flatten());
            if let Some(Fill::Solid { mut color }) = base {
                color.mods.retain(|m| !matches!(m, ColorTransform::Alpha(_)));
                if t > 0.0 {
@@ -690,7 +709,7 @@ fn line(s: &mut Session, p: &Value) -> Result<Value> {
        "miter" => deckcraft_model::style::LineJoin::Miter,
        _ => deckcraft_model::style::LineJoin::Round,
    });
-    edit_shapes(s, p, "shape.line", |sh| {
+    edit_group_appearance(s, p, "shape.line", |sh| {
        if reset {
            sh.line = None;
            return Ok(());
@@ -1503,6 +1522,95 @@ mod tests {
    use super::*;
    use serde_json::json;

+    fn nested_group() -> (Session, Vec<ShapeId>, ShapeId, ShapeId) {
+        let mut s = Session::with_new();
+        let mut ids = vec![];
+        for i in 0..4 {
+            let id = s.execute("shape.insert", &json!({"preset": "rect", "rect": [40 + i * 100, 100, 80, 60]})).unwrap()["id"].as_u64().unwrap();
+            s.execute("shape.line", &json!({"width": i + 1, "dash": "dash"})).unwrap();
+            ids.push(ShapeId(id as u32));
+        }
+        let group = |s: &mut Session, ids: &[ShapeId]| {
+            s.execute("edit.select", &json!({"ids": ids})).unwrap();
+            ShapeId(s.execute("arrange.group", &json!({})).unwrap()["id"].as_u64().unwrap() as u32)
+        };
+        let inner = group(&mut s, &ids[..2]);
+        let outer = group(&mut s, &[inner, ids[2]]);
+        (s, ids[..3].to_vec(), outer, ids[3])
+    }
+
+    #[test]
+    fn group_fill_reaches_nested_members_in_one_undo_step() {
+        let (mut s, members, group, outside) = nested_group();
+        let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
+        let untouched = serde_json::to_value(s.doc().unwrap().shape(outside)).unwrap();
+        s.execute("shape.fill", &json!({"color": "#ff0000"})).unwrap();
+        for id in &members {
+            assert_eq!(s.doc().unwrap().shape(*id).unwrap().fill, Some(Fill::solid(ColorRef::rgb(Rgba::rgb(255, 0, 0)))));
+        }
+        assert_eq!(s.doc().unwrap().selection.shapes, vec![group]);
+        assert_eq!(serde_json::to_value(s.doc().unwrap().shape(outside)).unwrap(), untouched);
+        let filled = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before);
+        s.execute("edit.redo", &json!({})).unwrap();
+        assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), filled);
+
+        s.execute("shape.fill", &json!({"none": true})).unwrap();
+        assert!(members.iter().all(|id| s.doc().unwrap().shape(*id).unwrap().fill == Some(Fill::None)));
+        s.execute("shape.fill", &json!({"reset": true})).unwrap();
+        assert!(members.iter().all(|id| s.doc().unwrap().shape(*id).unwrap().fill.is_none()));
+    }
+
+    #[test]
+    fn group_outline_reaches_members_without_resetting_their_other_properties() {
+        let (mut s, members, group, outside) = nested_group();
+        let before = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
+        // Explicit ids work even when another object is selected.
+        s.execute("edit.select", &json!({"ids": [outside]})).unwrap();
+        s.execute("shape.line", &json!({"ids": [group], "color": "#00ff00"})).unwrap();
+        for (i, id) in members.iter().enumerate() {
+            let line = s.doc().unwrap().shape(*id).unwrap().line.as_ref().unwrap();
+            assert_eq!(line.fill, Some(Fill::solid(ColorRef::rgb(Rgba::rgb(0, 255, 0)))));
+            assert_eq!(line.width, Some((i + 1) as f64));
+            assert_eq!(line.dash, Some(Dash::Preset { name: "dash".into() }));
+        }
+        assert_eq!(s.doc().unwrap().selection.shapes, vec![outside]);
+        let outlined = serde_json::to_value(&s.doc().unwrap().doc).unwrap();
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), before);
+        s.execute("edit.redo", &json!({})).unwrap();
+        assert_eq!(serde_json::to_value(&s.doc().unwrap().doc).unwrap(), outlined);
+        s.execute("shape.line", &json!({"ids": [group], "none": true})).unwrap();
+        assert!(members.iter().all(|id| s.doc().unwrap().shape(*id).unwrap().line.as_ref().unwrap().fill == Some(Fill::None)));
+        s.execute("shape.line", &json!({"ids": [group], "reset": true})).unwrap();
+        assert!(members.iter().all(|id| s.doc().unwrap().shape(*id).unwrap().line.is_none()));
+    }
+
+    #[test]
+    fn group_fill_transparency_keeps_each_members_inherited_colour() {
+        let (mut s, members, group, _) = nested_group();
+        s.execute("shape.fill", &json!({"ids": [members[1]], "color": "#00ff00"})).unwrap();
+        let colours: Vec<_> = {
+            let st = s.doc().unwrap();
+            let ctx = super::super::text::ctx_for(&st.doc, &st.selection).unwrap();
+            members
+                .iter()
+                .map(|id| {
+                    let (fill, ph) = deckcraft_model::resolve::fill(&ctx, st.shape(*id).unwrap());
+                    let Some(Fill::Solid { color }) = fill else { panic!("solid theme fill") };
+                    ctx.color(&color, ph)
+                })
+                .collect()
+        };
+        s.execute("shape.fill", &json!({"ids": [group], "transparency": 0.5})).unwrap();
+        for (id, colour) in members.iter().zip(colours) {
+            let mut expected = ColorRef::rgb(colour);
+            expected.mods.push(ColorTransform::Alpha(50000));
+            assert_eq!(s.doc().unwrap().shape(*id).unwrap().fill, Some(Fill::solid(expected)));
+        }
+    }
+
    fn rotation(s: &Session) -> f64 {
        let st = s.active().unwrap();
        let id = st.selection.shapes[0];
@@ -179,7 +179,7 @@ fn body_placeholder(shapes: &mut [deckcraft_model::Shape]) -> Option<&mut deckcr

 fn index_of(s: &Session, p: &Value) -> Result<usize> {
    let st = s.doc()?;
-    let i = usize_param(p, "index").unwrap_or(st.selection.slide);
+    let i = opt_usize_param(p, "index", "slide")?.unwrap_or(st.selection.slide);
    if i >= st.doc.slides.len() {
        return Err(bad("slide", format!("no slide {i}")));
    }
@@ -187,7 +187,7 @@ fn index_of(s: &Session, p: &Value) -> Result<usize> {
 }

 fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
-    let indices: Vec<usize> = match usize_param(p, "index") {
+    let indices: Vec<usize> = match opt_usize_param(p, "index", "slide.duplicate")? {
        Some(i) => vec![i],
        None => {
            let st = s.doc()?;
@@ -240,7 +240,7 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
        let st = s.doc()?;
        if let Some(a) = p.get("ids").and_then(Value::as_array) {
            a.iter().filter_map(Value::as_u64).filter_map(|v| u32::try_from(v).ok()).map(SlideId).collect()
-        } else if let Some(i) = usize_param(p, "index") {
+        } else if let Some(i) = opt_usize_param(p, "index", "slide.delete")? {
            st.doc.slides.get(i).map(|x| vec![x.id]).unwrap_or_default()
        } else if !st.selection.slides.is_empty() {
            st.selection.slides.clone()
@@ -266,7 +266,7 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
 }

 fn move_slide(s: &mut Session, p: &Value) -> Result<Value> {
-    let from = usize_param(p, "from").unwrap_or(s.doc()?.selection.slide);
+    let from = opt_usize_param(p, "from", "slide.move")?.unwrap_or(s.doc()?.selection.slide);
    let to = usize_param(p, "to").ok_or_else(|| bad("slide.move", "missing `to`"))?;
    s.edit(|doc, sel| {
        if from >= doc.slides.len() {
@@ -531,7 +531,7 @@ fn rename(s: &mut Session, p: &Value) -> Result<Value> {
 }

 fn section_add(s: &mut Session, p: &Value) -> Result<Value> {
-    let at = usize_param(p, "at").unwrap_or(s.doc()?.selection.slide);
+    let at = opt_usize_param(p, "at", "section.add")?.unwrap_or(s.doc()?.selection.slide);
    let name = str_param(p, "name").unwrap_or("Untitled Section").to_string();
    s.edit(|doc, _| {
        let at = at.min(doc.slides.len().saturating_sub(1));
@@ -648,6 +648,25 @@ mod tests {

    use crate::Session;

+    #[test]
+    fn invalid_index_params_are_rejected_not_defaulted_to_selection() {
+        let mut s = Session::with_new();
+        while s.doc().expect("doc").doc.slides.len() < 3 {
+            s.execute("slide.new", &json!({})).expect("new slide");
+        }
+        for bad in [json!(-1), json!(1.5)] {
+            for (cmd, p) in [
+                ("slide.delete", json!({"index": bad})),
+                ("slide.duplicate", json!({"index": bad})),
+                ("slide.move", json!({"from": bad, "to": 0})),
+                ("section.add", json!({"at": bad})),
+            ] {
+                assert!(s.execute(cmd, &p).is_err(), "{cmd} must reject {p}");
+                assert_eq!(s.doc().expect("doc").doc.slides.len(), 3, "{cmd} {p}");
+            }
+        }
+    }
+
    #[test]
    fn duplicate_keeps_section_order_in_step_with_slides() {
        let mut s = Session::with_new();
@@ -934,7 +934,7 @@ pub fn cell_range_underlines(
        return vec![];
    };
    let body = deckcraft_render::table_cell_body(&ctx, tb, row, col, cell);
-    let tmp = deckcraft_model::Shape { text: Some(body.clone()), ..Default::default() };
+    let tmp = deckcraft_model::Shape::table_cell(body.clone());
    let l = deckcraft_text::layout(
        &ctx,
        &tmp,
@@ -1003,7 +1003,7 @@ fn cell_on_slide(st: &DocState, id: ShapeId, row: usize, col: usize) -> Option<C
    if body.paragraphs.is_empty() {
        body.paragraphs.push(deckcraft_model::text::Paragraph::default());
    }
-    let tmp = deckcraft_model::Shape { text: Some(body.clone()), ..Default::default() };
+    let tmp = deckcraft_model::Shape::table_cell(body.clone());
    let layout = deckcraft_text::layout(
        &ctx,
        &tmp,
@@ -222,6 +222,9 @@ pub struct DocState {
    pub composition: Option<Composition>,
    /// Review › Compare in progress: the revised copy.
    pub compare: Option<compare::Compare>,
+    /// The last Duplicate: where it happened and each original with its copy, so duplicating the
+    /// copies again repeats how far they were moved, as in PowerPoint (#966).
+    pub last_duplicate: Option<(usize, Target, Vec<(ShapeId, ShapeId)>)>,
 }

 static NEXT_UID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
@@ -249,6 +252,7 @@ impl DocState {
            missing_fonts: Vec::new(),
            composition: None,
            compare: None,
+            last_duplicate: None,
        }
    }
    pub fn is_dirty(&self) -> bool {
@@ -44,6 +44,11 @@ pub fn instance_id() -> u64 {
    *ID.get_or_init(|| {
        use std::hash::{BuildHasher, Hasher};
        let mut h = std::collections::hash_map::RandomState::new().build_hasher();
+        // No PIDs and no std::time on wasm (`std::process::id()` and
+        // `SystemTime::now()` panic there): the browser clock stands in.
+        #[cfg(target_arch = "wasm32")]
+        h.write_u64(js_sys::Date::now() as u64);
+        #[cfg(not(target_arch = "wasm32"))]
        h.write_u32(std::process::id());
        #[cfg(not(target_arch = "wasm32"))]
        if let Ok(d) = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH) {
@@ -94,6 +94,23 @@ fn text_editing_flow() {
    assert_eq!(s.doc().unwrap().selection.shapes.len(), 1);
 }

+/// `text.set` treats CRLF (or a lone CR) as one paragraph break and keeps no `\r` in the text.
+#[test]
+fn text_set_crlf_makes_clean_paragraphs() {
+    let mut s = session();
+    let r = s.execute("insert.textBox", &json!({"text": "x"})).unwrap();
+    let id = r["id"].as_u64().unwrap();
+    s.execute("text.set", &json!({"id": id, "text": "one\r\ntwo"})).unwrap();
+    let t = s.execute("text.get", &json!({"id": id})).unwrap();
+    assert_eq!(t["paragraphs"][0]["text"], "one");
+    assert_eq!(t["paragraphs"][1]["text"], "two");
+    assert_eq!(t["text"], "one\ntwo");
+    // A lone CR (old Mac line ends) is a paragraph break too, as `edit::insert` treats it.
+    s.execute("text.set", &json!({"id": id, "text": "a\rb"})).unwrap();
+    let t = s.execute("text.get", &json!({"id": id})).unwrap();
+    assert_eq!(t["text"], "a\nb");
+}
+
 /// Cut with only a caret copies nothing, so it must not delete the character after the caret.
 #[test]
 fn cut_with_only_a_caret_changes_nothing() {
@@ -249,6 +266,49 @@ fn bold_copy_is_html_and_pages_html_pastes_bold() {
    assert_ne!(plain.paragraphs[0].runs[0].props.bold, Some(true));
 }

+#[test]
+fn html_paste_with_a_source_newline_keeps_its_bold() {
+    let mut s = session();
+    s.execute("edit.paste", &json!({"text": "Hello world", "html": "<p><b>Hello</b>\nworld</p>"})).unwrap();
+    let body = s
+        .doc()
+        .unwrap()
+        .current_slide()
+        .unwrap()
+        .shapes
+        .iter()
+        .find(|sh| sh.text.as_ref().is_some_and(|t| t.text() == "Hello world"))
+        .unwrap()
+        .text
+        .clone()
+        .unwrap();
+    assert_eq!(body.paragraphs[0].runs[0].props.bold, Some(true), "{body:?}");
+}
+
+#[test]
+fn html_paste_keeps_a_blank_nbsp_paragraph_and_the_rich_path() {
+    for blank in ["<p>&nbsp;</p>", "<p><o:p>&nbsp;</o:p></p>"] {
+        let mut s = session();
+        let html = format!("<p><b>A</b></p>{blank}<p>B</p>");
+        s.execute("edit.paste", &json!({"text": "A\n\u{a0}\nB", "html": html})).unwrap();
+        let body = s
+            .doc()
+            .unwrap()
+            .current_slide()
+            .unwrap()
+            .shapes
+            .iter()
+            .find(|sh| sh.text.as_ref().is_some_and(|t| t.paragraphs.len() == 3))
+            .unwrap()
+            .text
+            .clone()
+            .unwrap();
+        assert_eq!(body.paragraphs[0].runs[0].text, "A", "{html}: {body:?}");
+        assert_eq!(body.paragraphs[0].runs[0].props.bold, Some(true), "{html}: {body:?}");
+        assert_eq!(body.paragraphs[2].runs[0].text, "B", "{html}: {body:?}");
+    }
+}
+
 #[test]
 fn group_ungroup_roundtrip_positions() {
    let mut s = session();
@@ -2352,6 +2412,136 @@ fn picture_recolor_and_transparent_color() {
    assert_eq!(adj(&s), deckcraft_model::style::PictureAdjust::default());
 }

+#[test]
+fn transparent_color_at_a_point_takes_the_pictures_own_pixel_there() {
+    // Red on the left half, blue on the right.
+    let img = image::RgbaImage::from_fn(4, 2, |x, _| if x < 2 { image::Rgba([255, 0, 0, 255]) } else { image::Rgba([0, 0, 255, 255]) });
+    let mut png = vec![];
+    image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let mut s = session();
+    let id =
+        s.execute("insert.picture", &json!({"data": cmd::base64_encode(&png), "name": "a.png", "rect": [100, 100, 400, 200]})).unwrap()["id"].clone();
+    let clear = |s: &Session| match &s.doc().unwrap().shapes().iter().find(|sh| json!(sh.id) == id).unwrap().kind {
+        deckcraft_model::ShapeKind::Picture { fill } => fill.adjust.clear_color,
+        _ => panic!("not a picture"),
+    };
+    let red = deckcraft_color::Rgba::rgb(255, 0, 0);
+    let blue = deckcraft_color::Rgba::rgb(0, 0, 255);
+    s.execute("picture.transparentColor", &json!({"ids": [id], "at": [450, 200]})).unwrap();
+    assert_eq!(clear(&s), Some(blue));
+    // The picture's own colour, not the one drawn after a correction brightened it.
+    s.execute("picture.adjust", &json!({"ids": [id], "brightness": 0.4})).unwrap();
+    s.execute("picture.transparentColor", &json!({"ids": [id], "at": [150, 200]})).unwrap();
+    assert_eq!(clear(&s), Some(red));
+    // Flipped, the blue half is drawn on the left.
+    s.execute("shape.flip", &json!({"ids": [id], "axis": "horizontal"})).unwrap();
+    s.execute("picture.transparentColor", &json!({"ids": [id], "at": [150, 200]})).unwrap();
+    assert_eq!(clear(&s), Some(blue));
+    // Beside the picture there is no colour to take, and nothing changes.
+    assert!(s.execute("picture.transparentColor", &json!({"ids": [id], "at": [50, 50]})).is_err());
+    assert_eq!(clear(&s), Some(blue));
+    // A spot that is already transparent hides a colour (black here, as in most PNGs): taking it
+    // would clear the black drawn elsewhere in the picture.
+    let img = image::RgbaImage::from_fn(4, 2, |x, _| if x < 2 { image::Rgba([0, 0, 0, 0]) } else { image::Rgba([0, 0, 0, 255]) });
+    let mut png = vec![];
+    image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    let logo =
+        s.execute("insert.picture", &json!({"data": cmd::base64_encode(&png), "name": "b.png", "rect": [100, 400, 400, 200]})).unwrap()["id"].clone();
+    assert!(s.execute("picture.transparentColor", &json!({"ids": [logo], "at": [150, 500]})).is_err());
+    s.execute("picture.transparentColor", &json!({"ids": [logo], "at": [450, 500]})).unwrap();
+}
+
+/// A picture of `n` one-pixel columns whose red channel is 20 * column, inserted at `rect`.
+fn ramp_picture(s: &mut Session, n: u32, rect: [u32; 4]) -> serde_json::Value {
+    let img = image::RgbaImage::from_fn(n, 1, |x, _| image::Rgba([(20 * x) as u8, 0, 0, 255]));
+    let mut png = vec![];
+    image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+    s.execute("insert.picture", &json!({"data": cmd::base64_encode(&png), "name": "r.png", "rect": rect})).unwrap()["id"].clone()
+}
+
+fn clear_color_of(s: &Session, id: &serde_json::Value) -> Option<deckcraft_color::Rgba> {
+    fn find(shapes: &[deckcraft_model::Shape], id: &serde_json::Value) -> Option<deckcraft_model::Shape> {
+        shapes.iter().find_map(|sh| {
+            if json!(sh.id) == *id {
+                return Some(sh.clone());
+            }
+            match &sh.kind {
+                deckcraft_model::ShapeKind::Group { children, .. } => find(children, id),
+                _ => None,
+            }
+        })
+    }
+    match find(s.doc().unwrap().shapes(), id).unwrap().kind {
+        deckcraft_model::ShapeKind::Picture { fill } => fill.adjust.clear_color,
+        _ => panic!("not a picture"),
+    }
+}
+
+#[test]
+fn transparent_color_at_a_point_follows_the_pictures_3d_camera() {
+    let mut s = session();
+    let id = ramp_picture(&mut s, 10, [100, 100, 200, 100]);
+    // Turned 60 degrees about the vertical axis the picture is drawn about half as wide, centred
+    // where it was: 149..251 instead of 100..300.
+    s.execute("shape.effects", &json!({"ids": [id], "threeD": {"camera": "orthographicFront", "rotX": 60}})).unwrap();
+    // 175 is a quarter of the way across the drawn picture: column 2, not column 3 (the 75/200
+    // of the unturned box).
+    s.execute("picture.transparentColor", &json!({"ids": [id], "at": [175, 150]})).unwrap();
+    assert_eq!(clear_color_of(&s, &id), Some(deckcraft_color::Rgba::rgb(40, 0, 0)));
+    // Inside the unturned box but outside the drawn picture: nothing is under the pointer.
+    assert!(s.execute("picture.transparentColor", &json!({"ids": [id], "at": [120, 150]})).is_err());
+}
+
+#[test]
+fn transparent_color_at_a_point_finds_a_grouped_picture_without_its_own_box() {
+    let mut s = session();
+    let pic = ramp_picture(&mut s, 10, [100, 100, 200, 100]);
+    let other = s.execute("shape.insert", &json!({"preset": "rect", "rect": [400, 300, 50, 50]})).unwrap()["id"].clone();
+    s.execute("edit.select", &json!({"ids": [pic, other]})).unwrap();
+    s.execute("arrange.group", &json!({})).unwrap();
+    // A grouped picture that keeps no box of its own is drawn where the default box puts it.
+    let sz = s.doc().unwrap().doc.slide_size;
+    s.edit(|doc, sel| {
+        fn clear(shapes: &mut [deckcraft_model::Shape], id: &serde_json::Value) {
+            for sh in shapes {
+                if json!(sh.id) == *id {
+                    sh.xfrm = None;
+                }
+                if let deckcraft_model::ShapeKind::Group { children, .. } = &mut sh.kind {
+                    clear(children, id);
+                }
+            }
+        }
+        clear(crate::shapes_mut(doc, sel).unwrap(), &pic);
+        Ok(())
+    })
+    .unwrap();
+    // Left tenth of the default box (10%, 10%, 80% x 20% of the slide): column 0.
+    let at = [sz.width * 0.1 + 1.0, sz.height * 0.2];
+    s.execute("picture.transparentColor", &json!({"ids": [pic], "at": at})).unwrap();
+    assert_eq!(clear_color_of(&s, &pic), Some(deckcraft_color::Rgba::rgb(0, 0, 0)));
+    let at = [sz.width * 0.9 - 1.0, sz.height * 0.2];
+    s.execute("picture.transparentColor", &json!({"ids": [pic], "at": at})).unwrap();
+    assert_eq!(clear_color_of(&s, &pic), Some(deckcraft_color::Rgba::rgb(180, 0, 0)));
+}
+
+#[test]
+fn transparent_color_at_a_point_takes_the_topmost_selected_picture() {
+    let mut s = session();
+    // `under` is inserted first (drawn below), `over` after it (drawn on top); they overlap in x 150..300.
+    let under = ramp_picture(&mut s, 10, [100, 100, 200, 100]);
+    let over = ramp_picture(&mut s, 10, [150, 100, 200, 100]);
+    // Selected bottom first: selection order is the opposite of the stacking order.
+    s.execute("edit.select", &json!({"ids": [under, over]})).unwrap();
+    // x = 250 is column 7 of `under` (140) and column 5 of `over` (100): the click is on `over`.
+    s.execute("picture.transparentColor", &json!({"at": [250, 150]})).unwrap();
+    assert_eq!(clear_color_of(&s, &over), Some(deckcraft_color::Rgba::rgb(100, 0, 0)));
+    assert_eq!(clear_color_of(&s, &under), None);
+    // Where `over` is not, the picture below is still found.
+    s.execute("picture.transparentColor", &json!({"at": [120, 150]})).unwrap();
+    assert_eq!(clear_color_of(&s, &under), Some(deckcraft_color::Rgba::rgb(20, 0, 0)));
+}
+
 #[test]
 fn select_all_slides_scope() {
    let mut s = session();
@@ -3495,6 +3685,37 @@ fn find_and_replace_across_shapes_and_notes() {
    assert_eq!(s.execute("text.find", &q).unwrap().as_array().unwrap().len(), n - 1);
 }

+/// Find and Replace count a line break as one character, so offsets agree with the editor and no
+/// match spans the break.
+#[test]
+fn find_and_replace_after_a_line_break() {
+    let mut s = session();
+    let id = s.execute("insert.textBox", &json!({"rect": [10, 10, 300, 80], "text": "ab"})).unwrap()["id"].as_u64().unwrap();
+    s.execute("text.edit", &json!({"id": id, "end": true})).unwrap();
+    s.execute("text.insert", &json!({"text": "\u{b}cd"})).unwrap();
+    s.execute("text.exit", &json!({})).unwrap();
+    let text = |s: &Session| {
+        s.doc()
+            .unwrap()
+            .current_slide()
+            .unwrap()
+            .shapes
+            .iter()
+            .find(|x| u64::from(x.id.0) == id)
+            .and_then(|x| x.text.as_ref())
+            .map(|t| t.text())
+            .unwrap()
+    };
+    assert_eq!(text(&s), "ab\u{b}cd");
+    assert!(s.execute("text.find", &json!({"text": "bc"})).unwrap().as_array().unwrap().is_empty(), "no match spans the break");
+    let found = s.execute("text.find", &json!({"text": "cd"})).unwrap();
+    assert_eq!((found[0]["start"].as_u64(), found[0]["end"].as_u64()), (Some(3), Some(5)), "{found}");
+    s.execute("text.replace", &json!({"text": "cd", "with": "X"})).unwrap();
+    assert_eq!(text(&s), "ab\u{b}X");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(text(&s), "ab\u{b}cd");
+}
+
 #[test]
 fn pen_pressure_is_kept_and_a_mouse_draws_at_full_width() {
    let mut s = session();
@@ -4072,3 +4293,113 @@ fn a_shape_in_front_of_edited_text_takes_the_click() {
    let st = s.doc().unwrap();
    assert!(st.selection.text.as_ref().is_none_or(|t| t.shape.0 as u64 != tb), "the click on the member in front left the text: {:?}", st.selection);
 }
+
+/// A box at `rect` and a second box at `other` on a fresh slide; smart guides on, the grid off.
+/// The first box is selected.
+fn snap_scene(rect: [f64; 4], other: [f64; 4]) -> (Session, u64) {
+    let mut s = session();
+    s.prefs.snap_to_grid = false;
+    s.execute("shape.insert", &json!({"preset": "rect", "rect": other})).unwrap();
+    let id = s.execute("shape.insert", &json!({"preset": "rect", "rect": rect})).unwrap()["id"].as_u64().unwrap();
+    s.execute("edit.select", &json!({"ids": [id]})).unwrap();
+    s.prefs.smart_guides = true;
+    (s, id)
+}
+
+/// The slide box (`x`, `y`, `w`, `h`) of shape `id`, as `shape.inspect` reports it.
+fn box_of(s: &mut Session, id: u64) -> serde_json::Value {
+    s.execute("shape.inspect", &json!({"id": id})).unwrap()["box"].clone()
+}
+
+/// #961: dragging the east handle snaps the dragged (right) edge, even when the fixed left edge
+/// already lines up with another shape. The nearest line used to be the fixed edge's, at distance 0.
+#[test]
+fn resizing_snaps_the_dragged_edge_when_the_fixed_edge_is_already_aligned() {
+    // The box spans x 100..200; the other box starts at 100 too and ends at 300.
+    let (mut s, id) = snap_scene([100.0, 100.0, 100.0, 80.0], [100.0, 300.0, 200.0, 80.0]);
+    drag_gesture(&mut s, (200.0, 140.0), (297.0, 140.0));
+    let b = box_of(&mut s, id);
+    assert_eq!(b["x"], 100.0, "the fixed edge stays: {b}");
+    assert_eq!(b["w"], 200.0, "the right edge snaps to the other box's right edge at 300: {b}");
+}
+
+/// #961: only the dragged edge looks for a line. A fixed edge near a line must not shift the
+/// edge being dragged by its own distance.
+#[test]
+fn resizing_is_not_shifted_by_a_fixed_edge_near_a_line() {
+    // The other box starts at 103, 3 pt from the fixed left edge; the dragged edge ends far from any line.
+    let (mut s, id) = snap_scene([100.0, 100.0, 100.0, 80.0], [103.0, 300.0, 50.0, 80.0]);
+    drag_gesture(&mut s, (200.0, 140.0), (421.0, 140.0));
+    let b = box_of(&mut s, id);
+    assert_eq!(b["x"], 100.0, "the fixed edge stays: {b}");
+    assert_eq!(b["w"], 321.0, "the dragged edge goes where the pointer went: {b}");
+}
+
+/// #961: dragging a handle past the opposite edge flips the box, and the dragged edge becomes the
+/// other side of it: that side snaps, not the fixed one.
+#[test]
+fn resizing_past_the_opposite_edge_snaps_the_dragged_edge() {
+    // East handle of the box at x 100..200, dragged left past its left edge to 3, 3 pt from the
+    // other box's left edge at 0.
+    let (mut s, id) = snap_scene([100.0, 100.0, 100.0, 80.0], [0.0, 300.0, 50.0, 80.0]);
+    drag_gesture(&mut s, (200.0, 140.0), (3.0, 140.0));
+    let b = box_of(&mut s, id);
+    assert_eq!((b["x"].clone(), b["w"].clone()), (json!(0.0), json!(100.0)), "the dragged edge snaps to 0, the fixed edge stays at 100: {b}");
+    // South handle of the box at y 100..180, dragged up past its top edge to 3.
+    let (mut s, id) = snap_scene([100.0, 100.0, 100.0, 80.0], [300.0, 0.0, 80.0, 50.0]);
+    drag_gesture(&mut s, (150.0, 180.0), (150.0, 3.0));
+    let b = box_of(&mut s, id);
+    assert_eq!((b["y"].clone(), b["h"].clone()), (json!(0.0), json!(100.0)), "the dragged edge snaps to 0, the fixed edge stays at 100: {b}");
+}
+
+/// #961: the handles of a flipped box sit on the other side (the east handle draws on the left),
+/// and the edge under the dragged handle snaps.
+#[test]
+fn resizing_a_flipped_box_snaps_the_dragged_edge() {
+    // Flipped box at x 100..200: its east handle is at x 100. Dragged to 3, 3 pt from the other box's left edge at 0.
+    let (mut s, id) = snap_scene([100.0, 100.0, 100.0, 80.0], [0.0, 300.0, 50.0, 80.0]);
+    s.execute("shape.flip", &json!({"axis": "horizontal"})).unwrap();
+    drag_gesture(&mut s, (100.0, 140.0), (3.0, 140.0));
+    let b = box_of(&mut s, id);
+    assert_eq!((b["x"].clone(), b["w"].clone()), (json!(0.0), json!(200.0)), "the dragged edge snaps to 0, the fixed edge stays at 200: {b}");
+}
+
+#[test]
+fn duplicating_a_moved_copy_repeats_the_move() {
+    let mut s = session();
+    let r = s.execute("shape.insert", &json!({"preset": "rect", "rect": [100, 100, 50, 50]})).unwrap();
+    let a = r["id"].as_u64().unwrap();
+    let boxed = |s: &mut Session, id: u64| {
+        let v = s.execute("shape.inspect", &json!({"id": id})).unwrap();
+        (v["box"]["x"].as_f64().unwrap(), v["box"]["y"].as_f64().unwrap())
+    };
+    let dup = |s: &mut Session| s.execute("edit.duplicate", &json!({})).unwrap()["ids"][0].as_u64().unwrap();
+    // The first copy gets the usual offset.
+    let b = dup(&mut s);
+    let off = s.prefs.duplicate_offset;
+    assert_eq!(boxed(&mut s, b), (100.0 + off, 100.0 + off));
+    // Moved, then duplicated again: the next copy repeats the move from the original (#966).
+    s.execute("shape.move", &json!({"dx": 80.0 - off, "dy": -off})).unwrap();
+    assert_eq!(boxed(&mut s, b), (180.0, 100.0));
+    let c = dup(&mut s);
+    assert_eq!(boxed(&mut s, c), (260.0, 100.0));
+    let d = dup(&mut s);
+    assert_eq!(boxed(&mut s, d), (340.0, 100.0));
+    // Duplicating something else goes back to the usual offset.
+    s.doc_mut().unwrap().selection.shapes = vec![ShapeId(a as u32)];
+    let e = dup(&mut s);
+    assert_eq!(boxed(&mut s, e), (100.0 + off, 100.0 + off));
+    // Undone, its id can go to a new shape: duplicating that one uses the usual offset too.
+    s.execute("edit.undo", &json!({})).unwrap();
+    let r = s.execute("shape.insert", &json!({"preset": "ellipse", "rect": [400, 300, 40, 40]})).unwrap();
+    let g = r["id"].as_u64().unwrap();
+    assert_eq!(g, e, "the new shape reuses the undone copy's id");
+    let h = dup(&mut s);
+    assert_eq!(boxed(&mut s, h), (400.0 + off, 300.0 + off));
+    // After Undo removed that copy, duplicating the last moved copy gets the usual offset too.
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.doc_mut().unwrap().selection.shapes = vec![ShapeId(d as u32)];
+    let f = dup(&mut s);
+    assert_eq!(boxed(&mut s, f), (340.0 + off, 100.0 + off));
+    assert_eq!(s.doc().unwrap().doc.validate(), Vec::<String>::new());
+}
@@ -437,3 +437,147 @@ fn select_into_another_table_cell_settles_the_composition() {
    let cell = |c| t.cell(0, c).map(|x| x.text.text()).unwrap_or_default();
    assert_eq!((cell(0), cell(1)), ("abhello".to_string(), "X0123456789".to_string()));
 }
+
+/// Bold the first paragraph, select part of it and arm the Format Painter.
+fn painter_armed(sticky: bool) -> (Session, u32) {
+    let (mut s, id) = editing("Hello\nworld", (0, 0));
+    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [0, 5]})).unwrap();
+    s.execute("format.bold", &json!({"on": true})).unwrap();
+    s.execute("format.painter", &json!({"sticky": sticky})).unwrap();
+    (s, id)
+}
+
+fn bold_at(s: &mut Session, at: Pos) -> bool {
+    s.execute("text.select", &json!({"anchor": [at.0, at.1], "caret": [at.0, at.1 + 1]})).unwrap();
+    s.execute("format.state", &json!({})).unwrap()["bold"] == true
+}
+
+fn pointer(s: &mut Session, kind: crate::tools::PointerKind, x: f64, y: f64) {
+    s.pointer(crate::tools::PointerEvent { kind, x, y, tol: 4.0, ..Default::default() }).unwrap();
+}
+
+#[test]
+fn format_painter_applies_to_a_dragged_text_selection() {
+    use crate::tools::PointerKind::{Down, Drag, Up};
+    let (mut s, _) = painter_armed(false);
+    assert!(!bold_at(&mut s, (1, 0)));
+    s.execute("text.move", &json!({"to": "start"})).unwrap();
+    // Drag across the second line's text.
+    pointer(&mut s, Down, 68.0, 90.0);
+    pointer(&mut s, Drag, 110.0, 90.0);
+    pointer(&mut s, Up, 110.0, 90.0);
+    let t = s.doc().unwrap().selection.text.clone().unwrap();
+    assert!(t.is_range(), "the drag should select text");
+    assert!(s.painter.is_none(), "the painter is used up");
+    assert!(bold_at(&mut s, (1, 0)));
+}
+
+#[test]
+fn format_painter_applies_to_a_triple_clicked_paragraph() {
+    use crate::tools::PointerKind::TripleClick;
+    let (mut s, _) = painter_armed(true);
+    s.execute("text.select", &json!({"anchor": [1, 2], "caret": [1, 2]})).unwrap();
+    pointer(&mut s, TripleClick, 70.0, 90.0);
+    assert!(s.painter.is_some(), "a sticky painter stays armed");
+    assert!(bold_at(&mut s, (1, 0)));
+}
+
+#[test]
+fn format_painter_waits_for_a_range_on_a_plain_click() {
+    use crate::tools::PointerKind::{Down, Up};
+    let (mut s, _) = painter_armed(false);
+    pointer(&mut s, Down, 68.0, 90.0);
+    pointer(&mut s, Up, 68.0, 90.0);
+    assert!(s.painter.is_some());
+}
+
+#[test]
+fn format_painter_on_part_of_a_bulleted_line_keeps_its_bullet() {
+    use crate::tools::PointerKind::{Down, Drag, Up};
+    let (mut s, _) = painter_armed(false);
+    s.execute("text.select", &json!({"anchor": [1, 0], "caret": [1, 5]})).unwrap();
+    s.execute("format.bullets", &json!({"on": true})).unwrap();
+    let bulleted = |s: &mut Session| s.execute("format.state", &json!({})).unwrap()["bullets"] == true;
+    assert!(bulleted(&mut s));
+    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [0, 5]})).unwrap();
+    s.execute("format.painter", &json!({})).unwrap();
+    pointer(&mut s, Down, 68.0, 90.0);
+    pointer(&mut s, Drag, 100.0, 90.0);
+    pointer(&mut s, Up, 100.0, 90.0);
+    assert!(s.painter.is_none());
+    assert!(bold_at(&mut s, (1, 0)));
+    assert!(bulleted(&mut s), "the bullet stays");
+}
+
+/// Three bulleted paragraphs "one", "two", "three" and the painter armed from bold plain text.
+fn painter_over_bullets() -> Session {
+    let (mut s, _) = editing("one\ntwo\nthree\nplain", (0, 0));
+    s.execute("text.select", &json!({"anchor": [3, 0], "caret": [3, 5]})).unwrap();
+    s.execute("format.bold", &json!({"on": true})).unwrap();
+    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [2, 5]})).unwrap();
+    s.execute("format.bullets", &json!({"on": true})).unwrap();
+    s.execute("text.select", &json!({"anchor": [3, 0], "caret": [3, 5]})).unwrap();
+    s.execute("format.painter", &json!({})).unwrap();
+    s
+}
+
+fn bulleted(s: &mut Session, para: usize) -> bool {
+    s.execute("text.select", &json!({"anchor": [para, 0], "caret": [para, 0]})).unwrap();
+    s.execute("format.state", &json!({})).unwrap()["bullets"] == true
+}
+
+#[test]
+fn format_painter_paints_only_the_paragraphs_a_selection_covers() {
+    // Mid paragraph 0 to mid paragraph 2: only paragraph 1 is covered, so only it loses its bullet.
+    let mut s = painter_over_bullets();
+    s.execute("text.select", &json!({"anchor": [0, 1], "caret": [2, 2]})).unwrap();
+    s.execute("format.painterApply", &json!({})).unwrap();
+    assert_eq!([bulleted(&mut s, 0), bulleted(&mut s, 1), bulleted(&mut s, 2)], [true, false, true]);
+    // Start of paragraph 0 to mid paragraph 2: the partly covered last paragraph keeps its bullet.
+    let mut s = painter_over_bullets();
+    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [2, 2]})).unwrap();
+    s.execute("format.painterApply", &json!({})).unwrap();
+    assert_eq!([bulleted(&mut s, 0), bulleted(&mut s, 1), bulleted(&mut s, 2)], [false, false, true]);
+}
+
+#[test]
+fn format_painter_triple_click_leaves_the_next_paragraph_alone() {
+    use crate::tools::PointerKind::TripleClick;
+    let mut s = painter_over_bullets();
+    s.execute("text.select", &json!({"anchor": [0, 1], "caret": [0, 1]})).unwrap();
+    pointer(&mut s, TripleClick, 70.0, 70.0);
+    assert!(s.painter.is_none());
+    assert_eq!([bulleted(&mut s, 0), bulleted(&mut s, 1), bulleted(&mut s, 2)], [false, true, true]);
+}
+
+#[test]
+fn format_painter_ignores_a_double_click_that_selects_nothing() {
+    use crate::tools::PointerKind::DoubleClick;
+    let mut s = painter_over_bullets();
+    s.execute("text.select", &json!({"anchor": [0, 0], "caret": [1, 2]})).unwrap();
+    let before = sel(&s);
+    pointer(&mut s, DoubleClick, 900.0, 520.0);
+    assert_eq!(sel(&s), before);
+    assert!(s.painter.is_some(), "a click that left the selection alone keeps the painter");
+    assert!(bulleted(&mut s, 0));
+}
+
+#[test]
+fn format_painter_ignores_a_shift_press_that_leaves_the_selection() {
+    use crate::tools::PointerKind::{Down, Up};
+    let (mut s, _) = painter_armed(false);
+    // Find the caret position under the point, then select from the line start to it.
+    pointer(&mut s, Down, 110.0, 90.0);
+    pointer(&mut s, Up, 110.0, 90.0);
+    let k = caret(&s);
+    assert!(k.1 > 0);
+    s.execute("text.select", &json!({"anchor": [k.0, 0], "caret": [k.0, k.1]})).unwrap();
+    // Shift-pressing at the caret keeps the range, so there is nothing new to paint.
+    let shift = Mods { shift: true, ..NONE };
+    for kind in [Down, Up] {
+        s.pointer(crate::tools::PointerEvent { kind, x: 110.0, y: 90.0, mods: shift, tol: 4.0, ..Default::default() }).unwrap();
+    }
+    assert_eq!(sel(&s), ((k.0, 0), k));
+    assert!(s.painter.is_some(), "the painter stays armed");
+    assert!(!bold_at(&mut s, (1, 0)));
+}
@@ -34,6 +34,9 @@ pub struct Mods {
    pub cmd: bool,
 }

+/// A text selection's shape, table cell, notes flag, anchor and caret.
+type TextTarget = (ShapeId, Option<(usize, usize)>, bool, (usize, usize), (usize, usize));
+
 #[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct PointerEvent {
@@ -191,6 +194,8 @@ enum Drag {
    },
    TextSelect {
        shape: ShapeId,
+        /// The text selection before the press, to tell whether the drag changed it.
+        before: Option<TextTarget>,
    },
    /// Dragging a table border: the right edge of column `index`, or the bottom edge of row
    /// `index`. `start` is the table-local press point, `size` the column's width or the row's
@@ -474,11 +479,17 @@ impl Session {
            PointerKind::Down => self.down(p, ev.mods, tol),
            PointerKind::Drag => self.drag(p, ev.mods, tol),
            PointerKind::Up => self.up(p, ev.mods),
-            PointerKind::DoubleClick => self.double_click(p, tol),
+            PointerKind::DoubleClick => {
+                let before = self.text_selection();
+                let r = self.double_click(p, tol)?;
+                self.paint_if_selection_changed(before, r)
+            }
            PointerKind::ContextClick => self.context_click(p, tol),
            PointerKind::TripleClick => {
                if self.active().is_some_and(|d| d.selection.text.is_some()) {
-                    self.execute("text.selectParagraph", &json!({}))
+                    let before = self.text_selection();
+                    let r = self.execute("text.selectParagraph", &json!({}))?;
+                    self.paint_if_selection_changed(before, r)
                } else {
                    Ok(Value::Null)
                }
@@ -486,6 +497,27 @@ impl Session {
        }
    }

+    /// Format Painter applies once a text range is selected (drag, word or paragraph click).
+    fn paint_text_selection(&mut self) -> Result<Option<Value>> {
+        if self.painter.is_some() && self.doc()?.selection.text.as_ref().is_some_and(|t| t.is_range()) {
+            return self.execute("format.painterApply", &json!({})).map(Some);
+        }
+        Ok(None)
+    }
+
+    /// Where the text selection is: its shape, cell or notes, anchor and caret.
+    fn text_selection(&self) -> Option<TextTarget> {
+        self.active().and_then(|d| d.selection.text.as_ref()).map(|t| (t.shape, t.cell, t.notes, t.anchor, t.caret))
+    }
+
+    /// A double or triple click paints only the range it selected, not an older one it left alone.
+    fn paint_if_selection_changed(&mut self, before: Option<TextTarget>, r: Value) -> Result<Value> {
+        if self.text_selection() == before {
+            return Ok(r);
+        }
+        self.paint_text_selection().map(|a| a.unwrap_or(r))
+    }
+
    pub(crate) fn begin(&mut self, label: &str) {
        if let Some(st) = self.active_mut()
            && st.interaction.is_none()
@@ -552,8 +584,9 @@ impl Session {
            ToolKind::Select => {}
        }
        // Clicking inside the text being edited moves the caret / starts a text selection.
+        let before = self.text_selection();
        if let Some((shape, pos)) = self.place_caret(p, tol, mods.shift)? {
-            self.tool.drag = Some(Drag::TextSelect { shape });
+            self.tool.drag = Some(Drag::TextSelect { shape, before });
            return Ok(json!({"caret": [pos.0, pos.1]}));
        }
        let hit = self.hit_test(p, tol);
@@ -909,7 +942,7 @@ impl Session {
                };
                self.tool.preview = Some(x);
            }
-            Drag::TextSelect { shape } => {
+            Drag::TextSelect { shape, .. } => {
                // The selection stays in the shape or table cell where it started.
                let st = self.doc()?;
                if let Some(t) = st.selection.text.as_ref().filter(|t| t.shape == shape) {
@@ -1104,6 +1137,10 @@ impl Session {
                let _ = cmd::text::fit_text_box(self, id);
                self.refit_after_resize(id)?;
            }
+            Some(Drag::TextSelect { before, .. }) => {
+                out = self.paint_if_selection_changed(before, out)?;
+                self.commit();
+            }
            Some(_) => self.commit(),
            None => {}
        }
@@ -1449,6 +1486,13 @@ impl Session {
    /// Smart guides: snap `r` edges/centres to the slide and other shapes. Returns the offset to
    /// apply and the guides to draw.
    fn snap_rect(&self, r: Rect, exclude: &[ShapeId], tol: f64, enabled: bool) -> (Vec2, Vec<Guide>) {
+        self.snap_edges(r, exclude, tol, enabled, [true; 3], [true; 3])
+    }
+
+    /// `snap_rect` looking only at some of `r`'s edges: `xs_on` is left, centre, right and `ys_on`
+    /// top, centre, bottom. Resizing passes just the edges being dragged, so a fixed edge that
+    /// already sits on a line (distance 0) doesn't win and leave the dragged edge unsnapped.
+    fn snap_edges(&self, r: Rect, exclude: &[ShapeId], tol: f64, enabled: bool, xs_on: [bool; 3], ys_on: [bool; 3]) -> (Vec2, Vec<Guide>) {
        let Some(st) = self.active() else { return (Vec2::ZERO, vec![]) };
        if !enabled || !self.prefs.smart_guides {
            return (Vec2::ZERO, vec![]);
@@ -1486,7 +1530,7 @@ impl Session {
            }
        }
        let mut best_x: Option<(f64, f64, Rect)> = None;
-        for edge in [r.x0, r.center().x, r.x1] {
+        for edge in [r.x0, r.center().x, r.x1].into_iter().zip(xs_on).filter_map(|(e, on)| on.then_some(e)) {
            for (x, b) in &xs {
                let d = x - edge;
                if d.abs() <= tol && best_x.is_none_or(|(bd, _, _)| d.abs() < bd.abs()) {
@@ -1495,7 +1539,7 @@ impl Session {
            }
        }
        let mut best_y: Option<(f64, f64, Rect)> = None;
-        for edge in [r.y0, r.center().y, r.y1] {
+        for edge in [r.y0, r.center().y, r.y1].into_iter().zip(ys_on).filter_map(|(e, on)| on.then_some(e)) {
            for (y, b) in &ys {
                let d = y - edge;
                if d.abs() <= tol && best_y.is_none_or(|(bd, _, _)| d.abs() < bd.abs()) {
@@ -1509,32 +1553,49 @@ impl Session {
            off.x = d;
            let rr = r + Vec2::new(d, 0.0);
            guides.push(Guide { vertical: true, pos: x, from: b.y0.min(rr.y0), to: b.y1.max(rr.y1) });
-        } else if self.prefs.snap_to_grid {
-            off.x = deckcraft_geom::snap(r.x0, self.prefs.grid_spacing) - r.x0;
+        } else if self.prefs.snap_to_grid && xs_on.contains(&true) {
+            let at = if xs_on[0] {
+                r.x0
+            } else if xs_on[2] {
+                r.x1
+            } else {
+                r.center().x
+            };
+            off.x = deckcraft_geom::snap(at, self.prefs.grid_spacing) - at;
        }
        if let Some((d, y, b)) = best_y {
            off.y = d;
            let rr = r + Vec2::new(0.0, d);
            guides.push(Guide { vertical: false, pos: y, from: b.x0.min(rr.x0), to: b.x1.max(rr.x1) });
-        } else if self.prefs.snap_to_grid {
-            off.y = deckcraft_geom::snap(r.y0, self.prefs.grid_spacing) - r.y0;
+        } else if self.prefs.snap_to_grid && ys_on.contains(&true) {
+            let at = if ys_on[0] {
+                r.y0
+            } else if ys_on[2] {
+                r.y1
+            } else {
+                r.center().y
+            };
+            off.y = deckcraft_geom::snap(at, self.prefs.grid_spacing) - at;
        }
        (off, guides)
    }

+    /// Snap the edges that resize handle `handle` drags in the resized box `x` to the smart guides.
    fn snap_resize(&mut self, x: Xfrm, _orig: &Xfrm, handle: u8, id: ShapeId, tol: f64) -> Xfrm {
        if x.rot != 0.0 {
            self.tool.guides.clear();
            return x;
        }
        let r = x.rect();
-        let (off, guides) = self.snap_rect(r, &[id], tol * 1.5, true);
+        // Only the dragged edges move, so only they look for a line to snap to. The handles sit in
+        // the box's unflipped frame: in a flipped box, also one that a drag past the opposite edge
+        // just flipped, the dragged handle is on the other side.
+        let (left, right) = (matches!(handle, 0 | 6 | 7), matches!(handle, 2..=4));
+        let (top, bottom) = (matches!(handle, 0..=2), matches!(handle, 4..=6));
+        let (moves_left, moves_right) = if x.flip_h { (right, left) } else { (left, right) };
+        let (moves_top, moves_bottom) = if x.flip_v { (bottom, top) } else { (top, bottom) };
+        let (off, guides) = self.snap_edges(r, &[id], tol * 1.5, true, [moves_left, false, moves_right], [moves_top, false, moves_bottom]);
        let mut nx = x;
-        // Only the dragged edges move.
-        let moves_left = matches!(handle, 0 | 6 | 7);
-        let moves_right = matches!(handle, 2..=4);
-        let moves_top = matches!(handle, 0..=2);
-        let moves_bottom = matches!(handle, 4..=6);
        if moves_left {
            nx.x += off.x;
            nx.w -= off.x;
@@ -0,0 +1,2 @@
+mod chart_native;
+mod show_clicks;
@@ -15,4 +15,4 @@ harfrust = { workspace = true }
 unicode-bidi = { workspace = true }
 log = { workspace = true }
 # Last-resort face only (Ubuntu Light); no UI code.
-epaint_default_fonts = "0.36"
+epaint_default_fonts = "0.37"
@@ -498,8 +498,9 @@ fn sane_shapes(shapes: &mut [deckcraft_model::Shape], depth: usize) {
            }
        }
        match &mut sh.kind {
-            deckcraft_model::ShapeKind::Picture { fill } => {
-                for c in &mut fill.crop {
+            deckcraft_model::ShapeKind::Picture { fill: deckcraft_model::style::PictureFill { crop, .. } }
+            | deckcraft_model::ShapeKind::Media(deckcraft_model::MediaClip { crop, .. }) => {
+                for c in crop {
                    *c = if c.is_finite() { c.clamp(-10.0, 1.0) } else { 0.0 };
                }
            }
@@ -827,6 +828,18 @@ mod tests {
        assert!(load(&b).is_err());
    }

+    /// A video's crop is brought into the same range as a picture's (#972).
+    #[test]
+    fn a_video_crop_is_repaired_like_a_picture_crop() {
+        use deckcraft_model::{MediaClip, Shape};
+        let mut p = Presentation::default();
+        let clip = MediaClip { video: true, crop: [f64::NAN, 0.25, -1e9, 0.0], ..Default::default() };
+        Arc::make_mut(&mut p.slides[0]).shapes.push(Shape { kind: ShapeKind::Media(clip), ..Default::default() });
+        let back = load(&save(&p).unwrap()).unwrap_or_else(|e| panic!("{e}"));
+        let ShapeKind::Media(m) = &back.slides[0].shapes.last().unwrap().kind else { panic!("media") };
+        assert_eq!(m.crop, [0.0, 0.25, -10.0, 0.0]);
+    }
+
    /// Non-finite numbers are written as `null` by serde_json; the file still opens, with each
    /// such number repaired (it failed as "invalid type: null, expected f64").
    #[test]
@@ -33,7 +33,8 @@ pub struct SubPath {
 }

 /// A draggable adjust handle (the yellow dot). `pos = origin + dir * value`; dragging projects
-/// the pointer onto `dir`.
+/// the pointer onto `dir`. An `angle` handle instead measures the pointer's angle about `origin`
+/// (1/60 000 degree, y down, 0° at +x).
 #[derive(Clone, Debug, PartialEq)]
 pub struct Handle {
    pub index: usize,
@@ -42,14 +43,29 @@ pub struct Handle {
    pub dir: Vec2,
    pub min: f64,
    pub max: f64,
+    pub angle: bool,
 }

 impl Handle {
    fn new(index: usize, origin: Point, dir: Vec2, value: f64, min: f64, max: f64) -> Self {
-        Handle { index, pos: origin + dir * value, origin, dir, min, max }
+        Handle { index, pos: origin + dir * value, origin, dir, min, max, angle: false }
+    }
+    /// An angle handle on the `rx`×`ry` ellipse around `center` at visual angle `value`.
+    fn angle(index: usize, center: Point, rx: f64, ry: f64, value: f64) -> Self {
+        let t = vis(value / 60000.0, rx, ry).to_radians();
+        let pos = Point::new(center.x + rx * t.cos(), center.y + ry * t.sin());
+        Handle { index, pos, origin: center, dir: Vec2::ZERO, min: 0.0, max: 21600000.0, angle: true }
    }
    /// The adjust value for a pointer at `p` (shape-local space).
    pub fn value_at(&self, p: Point) -> f64 {
+        if self.angle {
+            let d = p - self.origin;
+            if !(d.x.is_finite() && d.y.is_finite()) || d.hypot() < 1e-9 {
+                return self.min;
+            }
+            let v = (d.y.atan2(d.x).to_degrees().rem_euclid(360.0) * 60000.0).round();
+            return if v >= self.max { self.min } else { v };
+        }
        let l2 = self.dir.hypot2();
        if l2 < 1e-18 {
            return self.min;
@@ -1082,7 +1098,15 @@ pub fn build(name: &str, w: f64, h: f64, adj: &[f64]) -> Option<Geometry> {
            b.m(p0.x, p0.y).arc(rx, ry, s0, sweep);
            let pi = Point::new(w / 2.0 + irx * si.to_radians().cos(), h / 2.0 + iry * si.to_radians().sin());
            b.l(pi.x, pi.y).arc(irx, iry, si, isweep).z();
-            simple(b.take(), full, w, h)
+            let mut g = simple(b.take(), full, w, h);
+            let c = Point::new(rx, ry);
+            g.handles.push(Handle::angle(0, c, rx - t / 2.0, ry - t / 2.0, a(0)));
+            // Thickness: slides inward from the outer edge along the end angle's ray.
+            let pe = Point::new(rx + rx * e0.to_radians().cos(), ry + ry * e0.to_radians().sin());
+            let u = (c - pe).normalize();
+            let u = if u.x.is_finite() && u.y.is_finite() { u } else { Vec2::ZERO };
+            g.handles.push(Handle::new(2, pe, u * (ss / 100000.0), a(2).clamp(0.0, 50000.0), 0.0, 50000.0));
+            g
        }
        "pie" | "chord" | "arc" => {
            let (rx, ry) = (w / 2.0, h / 2.0);
@@ -1095,7 +1119,7 @@ pub fn build(name: &str, w: f64, h: f64, adj: &[f64]) -> Option<Geometry> {
            let p0 = Point::new(rx + rx * s.to_radians().cos(), ry + ry * s.to_radians().sin());
            b.m(p0.x, p0.y).arc(rx, ry, s, sw);
            let text = Rect::new(w * 0.14645, h * 0.14645, w * 0.85355, h * 0.85355);
-            match name {
+            let mut g = match name {
                "pie" => {
                    b.l(rx, ry).z();
                    simple(b.take(), text, w, h)
@@ -1111,7 +1135,11 @@ pub fn build(name: &str, w: f64, h: f64, adj: &[f64]) -> Option<Geometry> {
                    f.close_path();
                    Geometry { paths: vec![fill_only(f), stroke_only(open)], text_rect: text, handles: vec![], sites: mid_sites(w, h) }
                }
-            }
+            };
+            let c = Point::new(rx, ry);
+            g.handles.push(Handle::angle(0, c, rx, ry, a(0)));
+            g.handles.push(Handle::angle(1, c, rx, ry, a(1)));
+            g
        }
        "teardrop" => {
            let k = a(0).clamp(0.0, 200000.0) / 100000.0;
@@ -1821,7 +1849,7 @@ fn ellipse_sites(w: f64, h: f64) -> Vec<Point> {

 fn tip_handle(w: f64, h: f64, tip: Point) -> Handle {
    // A free 2-D handle is represented as index 0 with zero direction; callers move both values.
-    Handle { index: 0, pos: tip, origin: Point::new(w / 2.0, h / 2.0), dir: Vec2::new(w / 1e5, h / 1e5), min: -1e6, max: 1e6 }
+    Handle { index: 0, pos: tip, origin: Point::new(w / 2.0, h / 2.0), dir: Vec2::new(w / 1e5, h / 1e5), min: -1e6, max: 1e6, angle: false }
 }

 fn wedge_rect(w: f64, h: f64, a0: f64, a1: f64, r: f64) -> Geometry {
@@ -2252,6 +2280,135 @@ mod tests {
        assert_eq!(h.value_at(Point::new(500.0, 0.0)), 50000.0);
    }

+    #[test]
+    fn partial_circle_angle_handles_map_back() {
+        // Start 0° sits at the right of the ellipse, end 270° at its top.
+        for name in ["pie", "chord", "arc"] {
+            let g = build(name, 200.0, 100.0, &[0.0, 16200000.0]).unwrap();
+            assert_eq!(g.handles.iter().map(|h| h.index).collect::<Vec<_>>(), vec![0, 1], "{name}");
+            let (s, e) = (&g.handles[0], &g.handles[1]);
+            assert!((s.pos - Point::new(200.0, 50.0)).hypot() < 1e-6, "{name} {:?}", s.pos);
+            assert!((e.pos - Point::new(100.0, 0.0)).hypot() < 1e-6, "{name} {:?}", e.pos);
+            assert_eq!(s.value_at(s.pos), 0.0, "{name}");
+            assert_eq!(e.value_at(e.pos), 16200000.0, "{name}");
+            // Dragging to the bottom of the ellipse gives 90°.
+            assert_eq!(s.value_at(Point::new(100.0, 100.0)), 5400000.0, "{name}");
+            // Off-axis angles on a non-square ellipse: the visual 45° ray meets the 200×100
+            // ellipse at offset (√2000, √2000) from the centre.
+            let k = 2000f64.sqrt();
+            let g = build(name, 200.0, 100.0, &[2700000.0, 8100000.0]).unwrap();
+            let (s, e) = (&g.handles[0], &g.handles[1]);
+            assert!((s.pos - Point::new(100.0 + k, 50.0 + k)).hypot() < 1e-6, "{name} {:?}", s.pos);
+            assert!((e.pos - Point::new(100.0 - k, 50.0 + k)).hypot() < 1e-6, "{name} {:?}", e.pos);
+            for (deg, h) in [(45.0, s), (135.0, e)] {
+                let on = ((h.pos.x - 100.0) / 100.0).powi(2) + ((h.pos.y - 50.0) / 50.0).powi(2);
+                assert!((on - 1.0).abs() < 1e-9, "{name} {deg}° off ellipse: {:?}", h.pos);
+                assert!((h.value_at(h.pos) - deg * 60000.0).abs() <= 1.0, "{name} {deg}°: {}", h.value_at(h.pos));
+            }
+        }
+        for deg in [45.0, 135.0, 200.0, 315.0] {
+            let g = build("blockArc", 200.0, 100.0, &[deg * 60000.0, 0.0, 25000.0]).unwrap();
+            let start = g.handles.iter().find(|h| h.index == 0).unwrap();
+            // Thickness 25 → the handle runs on the 87.5×37.5 mid-ring ellipse.
+            let on = ((start.pos.x - 100.0) / 87.5).powi(2) + ((start.pos.y - 50.0) / 37.5).powi(2);
+            assert!((on - 1.0).abs() < 1e-9, "blockArc {deg}° off ring: {:?}", start.pos);
+            let d = start.pos - Point::new(100.0, 50.0);
+            assert!((d.y.atan2(d.x).to_degrees().rem_euclid(360.0) - deg).abs() < 1e-6, "blockArc {deg}°: {:?}", start.pos);
+            assert!((start.value_at(start.pos) - deg * 60000.0).abs() <= 1.0, "blockArc {deg}°");
+        }
+        let g = build("blockArc", 200.0, 100.0, &[10800000.0, 0.0, 25000.0]).unwrap();
+        let start = g.handles.iter().find(|h| h.index == 0).unwrap();
+        assert_eq!(start.value_at(start.pos), 10800000.0);
+        let thick = g.handles.iter().find(|h| h.index == 2).unwrap();
+        assert!((thick.value_at(thick.pos) - 25000.0).abs() <= 1.0);
+    }
+
+    #[test]
+    fn presets_with_adjust_values_expose_handles() {
+        // Presets whose adjust values have no handle of their own yet.
+        const NO_HANDLES: &[&str] = &[
+            "curvedConnector3",
+            "snip2SameRect",
+            "snip2DiagRect",
+            "snipRoundRect",
+            "round1Rect",
+            "round2SameRect",
+            "round2DiagRect",
+            "teardrop",
+            "halfFrame",
+            "corner",
+            "diagStripe",
+            "foldedCorner",
+            "smileyFace",
+            "moon",
+            "gear6",
+            "gear9",
+            "bracketPair",
+            "bracePair",
+            "leftBracket",
+            "rightBracket",
+            "leftBrace",
+            "rightBrace",
+            "leftRightArrow",
+            "upDownArrow",
+            "quadArrow",
+            "leftRightUpArrow",
+            "bentArrow",
+            "uturnArrow",
+            "curvedRightArrow",
+            "curvedLeftArrow",
+            "curvedUpArrow",
+            "curvedDownArrow",
+            "leftUpArrow",
+            "bentUpArrow",
+            "circularArrow",
+            "leftCircularArrow",
+            "leftRightCircularArrow",
+            "swooshArrow",
+            "rightArrowCallout",
+            "downArrowCallout",
+            "leftArrowCallout",
+            "upArrowCallout",
+            "leftRightArrowCallout",
+            "upDownArrowCallout",
+            "quadArrowCallout",
+            "mathPlus",
+            "mathMinus",
+            "mathMultiply",
+            "mathDivide",
+            "mathEqual",
+            "mathNotEqual",
+            "ribbon2",
+            "ribbon",
+            "ellipseRibbon2",
+            "ellipseRibbon",
+            "leftRightRibbon",
+            "verticalScroll",
+            "horizontalScroll",
+            "wave",
+            "doubleWave",
+            "borderCallout1",
+            "borderCallout2",
+            "borderCallout3",
+            "accentCallout1",
+            "accentCallout2",
+            "accentCallout3",
+            "callout1",
+            "callout2",
+            "callout3",
+            "accentBorderCallout1",
+            "accentBorderCallout2",
+            "accentBorderCallout3",
+        ];
+        for p in CATALOG {
+            if p.defaults.is_empty() || NO_HANDLES.contains(&p.name) {
+                continue;
+            }
+            let g = build(p.name, 200.0, 100.0, &[]).unwrap();
+            assert!(!g.handles.is_empty(), "{} has adjust values but no handles", p.name);
+        }
+    }
+
    #[test]
    fn rect_area_and_ellipse_area() {
        let g = build("rect", 100.0, 50.0, &[]).unwrap();
@@ -10,5 +10,4 @@ rust-version.workspace = true
 workspace = true

 [dependencies]
-deckcraft-bitstream = { workspace = true }
-thiserror = { workspace = true }
+craft-media = { workspace = true, features = ["isobmff"] }
@@ -1,361 +0,0 @@
-//! Low-level helpers: four-character codes, a bounds-checked big-endian cursor, box iteration
-//! over in-memory payloads, and a box builder for the muxers.
-
-use crate::error::{Error, Result};
-use std::fmt;
-
-/// A four-character code (box type, sample entry format, brand, handler type…).
-#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
-pub struct FourCc(pub [u8; 4]);
-
-impl FourCc {
-    pub const fn new(b: &[u8; 4]) -> Self {
-        FourCc(*b)
-    }
-    pub fn as_u32(self) -> u32 {
-        u32::from_be_bytes(self.0)
-    }
-    /// Lossy string form; `©` (0xA9) is mapped to U+00A9, other non-printables to `?`.
-    pub fn to_string_lossy(self) -> String {
-        self.0
-            .iter()
-            .map(|&b| match b {
-                0xA9 => '©',
-                0x20..=0x7E => b as char,
-                _ => '?',
-            })
-            .collect()
-    }
-}
-
-impl fmt::Display for FourCc {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.to_string_lossy())
-    }
-}
-impl fmt::Debug for FourCc {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "FourCc({:?})", self.to_string_lossy())
-    }
-}
-impl From<&[u8; 4]> for FourCc {
-    fn from(b: &[u8; 4]) -> Self {
-        FourCc(*b)
-    }
-}
-impl PartialEq<[u8; 4]> for FourCc {
-    fn eq(&self, other: &[u8; 4]) -> bool {
-        &self.0 == other
-    }
-}
-impl PartialEq<&[u8; 4]> for FourCc {
-    fn eq(&self, other: &&[u8; 4]) -> bool {
-        &self.0 == *other
-    }
-}
-impl PartialEq<&&[u8; 4]> for FourCc {
-    fn eq(&self, other: &&&[u8; 4]) -> bool {
-        &self.0 == **other
-    }
-}
-
-/// Bounds-checked big-endian cursor over a byte slice.
-#[derive(Clone)]
-pub(crate) struct Cur<'a> {
-    pub data: &'a [u8],
-    pub pos: usize,
-    what: &'static str,
-}
-
-impl<'a> Cur<'a> {
-    pub fn new(data: &'a [u8], what: &'static str) -> Self {
-        Cur { data, pos: 0, what }
-    }
-    pub fn remaining(&self) -> usize {
-        self.data.len().saturating_sub(self.pos)
-    }
-    pub fn rest(&self) -> &'a [u8] {
-        self.data.get(self.pos..).unwrap_or(&[])
-    }
-    pub fn bytes(&mut self, n: usize) -> Result<&'a [u8]> {
-        let end = self.pos.checked_add(n).ok_or(Error::Truncated(self.what))?;
-        let s = self.data.get(self.pos..end).ok_or(Error::Truncated(self.what))?;
-        self.pos = end;
-        Ok(s)
-    }
-    pub fn skip(&mut self, n: usize) -> Result<()> {
-        self.bytes(n).map(|_| ())
-    }
-    pub fn array<const N: usize>(&mut self) -> Result<[u8; N]> {
-        let s = self.bytes(N)?;
-        let mut a = [0u8; N];
-        a.copy_from_slice(s);
-        Ok(a)
-    }
-    pub fn u8(&mut self) -> Result<u8> {
-        Ok(self.array::<1>()?[0])
-    }
-    pub fn u16(&mut self) -> Result<u16> {
-        Ok(u16::from_be_bytes(self.array()?))
-    }
-    pub fn i16(&mut self) -> Result<i16> {
-        Ok(i16::from_be_bytes(self.array()?))
-    }
-    pub fn u24(&mut self) -> Result<u32> {
-        let a = self.array::<3>()?;
-        Ok(((a[0] as u32) << 16) | ((a[1] as u32) << 8) | a[2] as u32)
-    }
-    pub fn u32(&mut self) -> Result<u32> {
-        Ok(u32::from_be_bytes(self.array()?))
-    }
-    pub fn i32(&mut self) -> Result<i32> {
-        Ok(i32::from_be_bytes(self.array()?))
-    }
-    pub fn u64(&mut self) -> Result<u64> {
-        Ok(u64::from_be_bytes(self.array()?))
-    }
-    pub fn i64(&mut self) -> Result<i64> {
-        Ok(i64::from_be_bytes(self.array()?))
-    }
-    pub fn f64(&mut self) -> Result<f64> {
-        Ok(f64::from_be_bytes(self.array()?))
-    }
-    pub fn fourcc(&mut self) -> Result<FourCc> {
-        Ok(FourCc(self.array()?))
-    }
-    /// Full-box header: (version, flags).
-    pub fn full_header(&mut self) -> Result<(u8, u32)> {
-        let v = self.u32()?;
-        Ok(((v >> 24) as u8, v & 0x00FF_FFFF))
-    }
-    /// Read a count and verify that `count * entry_size` bytes remain (allocation guard).
-    pub fn count(&mut self, entry_size: usize) -> Result<usize> {
-        let n = self.u32()? as usize;
-        self.check_count(n, entry_size)?;
-        Ok(n)
-    }
-    pub fn check_count(&self, n: usize, entry_size: usize) -> Result<()> {
-        match n.checked_mul(entry_size) {
-            Some(b) if b <= self.remaining() => Ok(()),
-            _ => Err(Error::Truncated(self.what)),
-        }
-    }
-}
-
-/// Header of one box as found in a byte stream.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) struct BoxHeader {
-    pub kind: FourCc,
-    /// Header length including largesize and uuid extended type.
-    pub header_len: u64,
-    /// Total box size including header; `None` means "extends to end of the enclosing container".
-    pub size: Option<u64>,
-    pub uuid: Option<[u8; 16]>,
-}
-
-/// Parse a box header from `buf` (needs up to 32 bytes; fewer if available).
-pub(crate) fn parse_box_header(buf: &[u8]) -> Result<BoxHeader> {
-    let mut c = Cur::new(buf, "box header");
-    let size32 = c.u32()?;
-    let kind = c.fourcc()?;
-    let mut header_len = 8u64;
-    let size = match size32 {
-        0 => None,
-        1 => {
-            header_len += 8;
-            let s = c.u64()?;
-            Some(s)
-        }
-        s => Some(s as u64),
-    };
-    let uuid = if kind == b"uuid" {
-        header_len += 16;
-        Some(c.array::<16>()?)
-    } else {
-        None
-    };
-    if let Some(s) = size
-        && s < header_len
-    {
-        return Err(Error::Invalid(format!("box '{kind}' size {s} smaller than its header")));
-    }
-    Ok(BoxHeader { kind, header_len, size, uuid })
-}
-
-/// One child box inside an in-memory payload.
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct RawBox<'a> {
-    pub kind: FourCc,
-    pub payload: &'a [u8],
-    #[allow(dead_code)]
-    pub uuid: Option<[u8; 16]>,
-}
-
-/// Iterator over the child boxes of a payload. Yields an error for a malformed box and then stops.
-pub(crate) struct Boxes<'a> {
-    data: &'a [u8],
-    pos: usize,
-    done: bool,
-}
-
-pub(crate) fn boxes(data: &[u8]) -> Boxes<'_> {
-    Boxes { data, pos: 0, done: false }
-}
-
-impl<'a> Iterator for Boxes<'a> {
-    type Item = Result<RawBox<'a>>;
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.done {
-            return None;
-        }
-        let rest = &self.data[self.pos..];
-        if rest.is_empty() {
-            self.done = true;
-            return None;
-        }
-        // QuickTime allows a 32-bit zero terminator at the end of some containers.
-        if rest.len() < 8 {
-            self.done = true;
-            if rest.iter().all(|&b| b == 0) {
-                return None;
-            }
-            return Some(Err(Error::Truncated("box header")));
-        }
-        let h = match parse_box_header(rest) {
-            Ok(h) => h,
-            Err(e) => {
-                self.done = true;
-                return Some(Err(e));
-            }
-        };
-        let size = h.size.unwrap_or(rest.len() as u64);
-        if size > rest.len() as u64 {
-            self.done = true;
-            return Some(Err(Error::Invalid(format!("box '{}' size {} exceeds its container ({} bytes left)", h.kind, size, rest.len()))));
-        }
-        let size = size as usize;
-        let payload = &rest[h.header_len as usize..size];
-        self.pos += size;
-        Some(Ok(RawBox { kind: h.kind, payload, uuid: h.uuid }))
-    }
-}
-
-/// Find the first child of the given type (malformed trailing children are ignored).
-pub(crate) fn find<'a>(data: &'a [u8], kind: &[u8; 4]) -> Option<&'a [u8]> {
-    boxes(data).map_while(|b| b.ok()).find(|b| b.kind == kind).map(|b| b.payload)
-}
-
-/// Growable buffer for building boxes.
-#[derive(Default, Clone, Debug)]
-pub(crate) struct BoxBuf {
-    pub buf: Vec<u8>,
-}
-
-impl BoxBuf {
-    pub fn new() -> Self {
-        Self::default()
-    }
-    /// Begin a box; returns a marker to pass to [`end`](Self::end).
-    pub fn start(&mut self, kind: &[u8; 4]) -> usize {
-        let at = self.buf.len();
-        self.buf.extend_from_slice(&[0, 0, 0, 0]);
-        self.buf.extend_from_slice(kind);
-        at
-    }
-    pub fn start_full(&mut self, kind: &[u8; 4], version: u8, flags: u32) -> usize {
-        let at = self.start(kind);
-        self.u32(((version as u32) << 24) | (flags & 0xFF_FFFF));
-        at
-    }
-    pub fn end(&mut self, at: usize) {
-        let size = (self.buf.len() - at) as u32;
-        self.buf[at..at + 4].copy_from_slice(&size.to_be_bytes());
-    }
-    /// Append a complete box with the given payload.
-    pub fn leaf(&mut self, kind: &[u8; 4], payload: &[u8]) {
-        let at = self.start(kind);
-        self.bytes(payload);
-        self.end(at);
-    }
-    pub fn u8(&mut self, v: u8) {
-        self.buf.push(v);
-    }
-    pub fn u16(&mut self, v: u16) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn i16(&mut self, v: i16) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn u32(&mut self, v: u32) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn i32(&mut self, v: i32) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn u64(&mut self, v: u64) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn i64(&mut self, v: i64) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn f64(&mut self, v: f64) {
-        self.buf.extend_from_slice(&v.to_be_bytes());
-    }
-    pub fn bytes(&mut self, b: &[u8]) {
-        self.buf.extend_from_slice(b);
-    }
-    pub fn zeros(&mut self, n: usize) {
-        self.buf.resize(self.buf.len() + n, 0);
-    }
-    pub fn len(&self) -> usize {
-        self.buf.len()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn header_forms() {
-        let h = parse_box_header(&[0, 0, 0, 16, b'f', b'r', b'e', b'e']).unwrap();
-        assert_eq!((h.kind, h.header_len, h.size), (FourCc(*b"free"), 8, Some(16)));
-        let h = parse_box_header(&[0, 0, 0, 0, b'm', b'd', b'a', b't']).unwrap();
-        assert_eq!(h.size, None);
-        let mut v = vec![0, 0, 0, 1, b'm', b'd', b'a', b't'];
-        v.extend_from_slice(&100u64.to_be_bytes());
-        let h = parse_box_header(&v).unwrap();
-        assert_eq!((h.header_len, h.size), (16, Some(100)));
-        let mut v = vec![0, 0, 0, 30, b'u', b'u', b'i', b'd'];
-        v.extend_from_slice(&[7u8; 16]);
-        let h = parse_box_header(&v).unwrap();
-        assert_eq!((h.header_len, h.uuid), (24, Some([7u8; 16])));
-        assert!(parse_box_header(&[0, 0, 0, 4, b'f', b'r', b'e', b'e']).is_err());
-        assert!(parse_box_header(&[0, 0, 0]).is_err());
-    }
-
-    #[test]
-    fn iterate_children() {
-        let mut b = BoxBuf::new();
-        b.leaf(b"aaaa", &[1, 2]);
-        let m = b.start(b"bbbb");
-        b.leaf(b"cccc", &[]);
-        b.end(m);
-        b.u32(0); // QT terminator
-        let kids: Vec<_> = boxes(&b.buf).collect::<Result<Vec<_>>>().unwrap();
-        assert_eq!(kids.len(), 2);
-        assert_eq!(kids[0].payload, &[1, 2]);
-        assert_eq!(find(&b.buf, b"bbbb").map(|p| p.len()), Some(8));
-        // Oversized child → error, no panic.
-        let bad = [0u8, 0, 0, 99, b'x', b'x', b'x', b'x', 0];
-        assert!(boxes(&bad).next().unwrap().is_err());
-    }
-
-    #[test]
-    fn cursor_bounds() {
-        let mut c = Cur::new(&[0, 0, 0, 5, 1], "t");
-        assert!(c.count(1).is_err());
-        let mut c = Cur::new(&[0xFF, 0xFF, 0xFF, 0xFF], "t");
-        assert!(c.count(usize::MAX).is_err());
-    }
-}
@@ -1,38 +0,0 @@
-use std::io;
-
-/// Errors produced by the demuxer and muxer.
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("I/O error: {0}")]
-    Io(#[from] io::Error),
-    /// A box or structure ended before all required fields were read.
-    #[error("truncated data while reading {0}")]
-    Truncated(&'static str),
-    /// Structurally invalid data.
-    #[error("invalid data: {0}")]
-    Invalid(String),
-    /// Valid but unsupported feature (e.g. compressed `cmov` movie header).
-    #[error("unsupported: {0}")]
-    Unsupported(String),
-    /// A count or size exceeds sanity limits relative to the file size.
-    #[error("size limit exceeded: {0}")]
-    TooLarge(&'static str),
-    /// No `moov` box was found.
-    #[error("no moov box found")]
-    NoMoov,
-    /// A track index was out of range.
-    #[error("track index {0} out of range")]
-    NoSuchTrack(usize),
-    /// A sample index was out of range.
-    #[error("sample index {0} out of range")]
-    NoSuchSample(usize),
-    /// Muxer usage error (e.g. invalid track config, bad sample).
-    #[error("muxer: {0}")]
-    Mux(String),
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-pub(crate) fn invalid<T>(msg: impl Into<String>) -> Result<T> {
-    Err(Error::Invalid(msg.into()))
-}
@@ -1,28 +1,6 @@
-//! Clean-room ISO Base Media File Format (MP4, ISO/IEC 14496-12/14/15) and QuickTime (MOV) support.
-//!
-//! - **Demux:** [`open`] parses box headers plus `moov` (and `moof` for fragmented files) from a
-//!   [`ByteSource`] and builds per-track [`Sample`] tables; media data is read on demand with
-//!   [`Mp4File::read_sample`].
-//! - **Mux:** [`Mp4Writer`] writes progressive MP4/MOV (optionally faststart);
-//!   [`FragmentedWriter`] writes fragmented MP4.
-//!
-//! See the crate README for supported boxes and limitations.
+//! ISO BMFF (MP4) and QuickTime (MOV) demuxer and muxer: a re-export of [`craft_media::isobmff`]
+//! from craft-libs. Supported boxes and limitations are in the craft-media README.

 #![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable))]

-mod bytes;
-mod codec;
-mod demux;
-mod error;
-mod mux;
-mod source;
-
-pub use bytes::FourCc;
-pub use codec::{
-    AacConfig, AudioParams, Av1Config, AvcConfig, BitRate, CleanAperture, CodecConfig, ColorInfo, FieldInfo, FlacConfig, HevcConfig, HevcNalArray,
-    MasteringDisplay, OpusConfig, PcmConfig, SampleEntry, TimecodeConfig, VideoParams, VpcConfig, parse_asc,
-};
-pub use demux::{Edit, Metadata, Mp4File, Sample, SampleGroup, Track, TrackKind, open};
-pub use error::{Error, Result};
-pub use mux::{Brand, FragmentedWriter, Mp4Writer, TrackConfig, WriteSample, WriterOptions};
-pub use source::ByteSource;
+pub use craft_media::isobmff::*;
@@ -1,969 +0,0 @@
-//! Muxers: progressive MP4/MOV ([`Mp4Writer`], optional faststart) and fragmented MP4 ([`FragmentedWriter`]).
-
-use crate::bytes::BoxBuf;
-use crate::codec::{CodecConfig, SampleEntry, TimecodeConfig};
-use crate::demux::Edit;
-use crate::error::{Error, Result};
-use std::io::{Read, Seek, SeekFrom, Write};
-
-/// Output flavour: determines brands and some sample-entry encodings.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Brand {
-    /// ISO MP4: `isom` major brand, compatible `isom iso2 avc1 mp41 mp42`.
-    Mp4,
-    /// QuickTime MOV: `qt  ` major brand.
-    Mov,
-}
-
-/// Movie-level writer options.
-#[derive(Clone, Debug)]
-pub struct WriterOptions {
-    pub brand: Brand,
-    /// Movie timescale (`mvhd`); default 1000.
-    pub movie_timescale: u32,
-    /// Text metadata written to `moov/udta` (keys like `©nam`, `©ART`, `©cmt`, `©too`).
-    pub metadata: Vec<(String, String)>,
-}
-
-impl WriterOptions {
-    pub fn new(brand: Brand) -> Self {
-        WriterOptions { brand, movie_timescale: 1000, metadata: Vec::new() }
-    }
-}
-
-/// Per-track configuration.
-#[derive(Clone, Debug)]
-pub struct TrackConfig {
-    pub entry: SampleEntry,
-    /// Media timescale. For PCM it must equal the sample rate (one tick per audio frame).
-    pub timescale: u32,
-    /// ISO 639-2/T language (`und` by default).
-    pub language: String,
-    /// Explicit edit list (segment durations in the movie timescale). Takes precedence over `media_start`.
-    pub edits: Vec<Edit>,
-    /// Convenience: create one edit starting at this media time (e.g. AAC encoder delay / priming,
-    /// or the first pts of a B-frame stream) spanning the rest of the media.
-    pub media_start: Option<i64>,
-    /// `hdlr` name; a sensible default is used when `None`.
-    pub handler_name: Option<String>,
-}
-
-impl TrackConfig {
-    pub fn new(entry: SampleEntry, timescale: u32) -> Self {
-        TrackConfig { entry, timescale, language: "und".into(), edits: Vec::new(), media_start: None, handler_name: None }
-    }
-}
-
-/// A sample handed to the muxers.
-#[derive(Clone, Copy, Debug)]
-pub struct WriteSample<'a> {
-    pub data: &'a [u8],
-    /// Duration in the media timescale. Ignored for PCM (each frame lasts one tick).
-    pub duration: u32,
-    /// pts − dts in the media timescale.
-    pub composition_offset: i32,
-    pub is_sync: bool,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Handler {
-    Video,
-    Audio,
-    Timecode,
-    Other,
-}
-
-fn handler_of(e: &SampleEntry) -> Handler {
-    if matches!(e.codec, CodecConfig::Timecode(_)) {
-        Handler::Timecode
-    } else if e.video.is_some() {
-        Handler::Video
-    } else if e.audio.is_some() {
-        Handler::Audio
-    } else {
-        Handler::Other
-    }
-}
-
-/// Accumulated sample tables for one track.
-#[derive(Clone, Debug, Default)]
-struct Tables {
-    stts: Vec<(u32, u32)>,
-    ctts: Vec<(u32, i32)>,
-    sizes: Vec<u32>,
-    /// Constant sample size (PCM) — then `sizes` is unused.
-    const_size: Option<u32>,
-    sample_count: u64,
-    /// 1-based sync sample numbers.
-    sync: Vec<u32>,
-    all_sync: bool,
-    /// (offset relative to file start before shifting, sample count)
-    chunks: Vec<(u64, u32)>,
-    media_duration: u64,
-    /// End of the last sample on the composition timeline (decode time + composition offset +
-    /// duration, maximum over samples).
-    comp_end: u64,
-}
-
-impl Tables {
-    fn new() -> Self {
-        Tables { all_sync: true, ..Default::default() }
-    }
-    fn push_run<T: PartialEq + Copy>(runs: &mut Vec<(u32, T)>, count: u32, v: T) {
-        if let Some(last) = runs.last_mut()
-            && last.1 == v
-            && last.0.checked_add(count).is_some()
-        {
-            last.0 += count;
-            return;
-        }
-        runs.push((count, v));
-    }
-}
-
-struct WTrack {
-    cfg: TrackConfig,
-    id: u32,
-    handler: Handler,
-    pcm_frame_bytes: Option<u32>,
-    t: Tables,
-    /// Track id of a linked timecode track (`tref/tmcd`).
-    tmcd_ref: Option<u32>,
-    /// For timecode tracks: (video track index, start frame).
-    tmcd_source: Option<(usize, u32)>,
-}
-
-fn pack_language(lang: &str) -> u16 {
-    let b = lang.as_bytes();
-    if b.len() == 3 && b.iter().all(|c| c.is_ascii_lowercase()) {
-        (((b[0] - 0x60) as u16) << 10) | (((b[1] - 0x60) as u16) << 5) | ((b[2] - 0x60) as u16)
-    } else {
-        0x55C4 // "und"
-    }
-}
-
-fn rescale(v: u64, from: u32, to: u32) -> u64 {
-    if from == 0 {
-        return 0;
-    }
-    (v as u128 * to as u128 / from as u128).min(u64::MAX as u128) as u64
-}
-
-const MATRIX: [i32; 9] = [0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x4000_0000];
-
-fn write_ftyp(b: &mut BoxBuf, brand: Brand) {
-    let m = b.start(b"ftyp");
-    match brand {
-        Brand::Mp4 => {
-            b.bytes(b"isom");
-            b.u32(0x200);
-            for c in [b"isom", b"iso2", b"avc1", b"mp41", b"mp42"] {
-                b.bytes(c);
-            }
-        }
-        Brand::Mov => {
-            b.bytes(b"qt  ");
-            b.u32(0x200);
-            b.bytes(b"qt  ");
-        }
-    }
-    b.end(m);
-}
-
-fn movie_duration(tracks: &[WTrack], movie_ts: u32) -> u64 {
-    tracks.iter().map(|t| presentation_duration(t, movie_ts)).max().unwrap_or(0)
-}
-
-fn effective_edits(t: &WTrack, movie_ts: u32) -> Vec<Edit> {
-    if !t.cfg.edits.is_empty() {
-        return t.cfg.edits.clone();
-    }
-    if let Some(start) = t.cfg.media_start {
-        // presentation runs from `start` to the end of the last sample in composition order (with
-        // B-frame reordering that is past the end of the decode timeline)
-        let rest = t.t.comp_end.max(t.t.media_duration).saturating_sub(start.max(0) as u64);
-        return vec![Edit { segment_duration: rescale(rest, t.cfg.timescale, movie_ts), media_time: start, media_rate: 0x10000 }];
-    }
-    Vec::new()
-}
-
-fn presentation_duration(t: &WTrack, movie_ts: u32) -> u64 {
-    let e = effective_edits(t, movie_ts);
-    if e.is_empty() { rescale(t.t.media_duration, t.cfg.timescale, movie_ts) } else { e.iter().map(|e| e.segment_duration).sum() }
-}
-
-fn write_mvhd(b: &mut BoxBuf, timescale: u32, duration: u64, next_id: u32) {
-    let v1 = duration > u32::MAX as u64;
-    let m = b.start_full(b"mvhd", v1 as u8, 0);
-    if v1 {
-        b.u64(0);
-        b.u64(0);
-        b.u32(timescale);
-        b.u64(duration);
-    } else {
-        b.u32(0);
-        b.u32(0);
-        b.u32(timescale);
-        b.u32(duration as u32);
-    }
-    b.u32(0x10000);
-    b.u16(0x100);
-    b.zeros(10);
-    for v in MATRIX {
-        b.i32(v);
-    }
-    b.zeros(24);
-    b.u32(next_id);
-    b.end(m);
-}
-
-fn write_trak(b: &mut BoxBuf, t: &WTrack, movie_ts: u32, qt: bool, shift: u64, force_co64: bool) -> Result<()> {
-    let trak = b.start(b"trak");
-    let dur = presentation_duration(t, movie_ts);
-    let v1 = dur > u32::MAX as u64;
-    let m = b.start_full(b"tkhd", v1 as u8, 3);
-    if v1 {
-        b.u64(0);
-        b.u64(0);
-        b.u32(t.id);
-        b.u32(0);
-        b.u64(dur);
-    } else {
-        b.u32(0);
-        b.u32(0);
-        b.u32(t.id);
-        b.u32(0);
-        b.u32(dur as u32);
-    }
-    b.zeros(8);
-    b.i16(0);
-    b.u16(0);
-    b.i16(if t.handler == Handler::Audio { 0x100 } else { 0 });
-    b.u16(0);
-    for v in MATRIX {
-        b.i32(v);
-    }
-    let (w, h) = match &t.cfg.entry.video {
-        Some(v) => {
-            let w = match v.pixel_aspect {
-                Some((hs, vs)) if hs > 0 && vs > 0 => (v.width as u64 * hs as u64 / vs as u64) as u32,
-                _ => v.width as u32,
-            };
-            (w, v.height as u32)
-        }
-        None => (0, 0),
-    };
-    b.u32(w << 16);
-    b.u32(h << 16);
-    b.end(m);
-    let edits = effective_edits(t, movie_ts);
-    if !edits.is_empty() {
-        let e = b.start(b"edts");
-        let v1 = edits.iter().any(|e| e.segment_duration > u32::MAX as u64 || e.media_time > i32::MAX as i64 || e.media_time < i32::MIN as i64);
-        let l = b.start_full(b"elst", v1 as u8, 0);
-        b.u32(edits.len() as u32);
-        for ed in &edits {
-            if v1 {
-                b.u64(ed.segment_duration);
-                b.i64(ed.media_time);
-            } else {
-                b.u32(ed.segment_duration as u32);
-                b.i32(ed.media_time as i32);
-            }
-            b.i32(ed.media_rate);
-        }
-        b.end(l);
-        b.end(e);
-    }
-    if let Some(id) = t.tmcd_ref {
-        let r = b.start(b"tref");
-        let m = b.start(b"tmcd");
-        b.u32(id);
-        b.end(m);
-        b.end(r);
-    }
-    let mdia = b.start(b"mdia");
-    let mv1 = t.t.media_duration > u32::MAX as u64;
-    let m = b.start_full(b"mdhd", mv1 as u8, 0);
-    if mv1 {
-        b.u64(0);
-        b.u64(0);
-        b.u32(t.cfg.timescale);
-        b.u64(t.t.media_duration);
-    } else {
-        b.u32(0);
-        b.u32(0);
-        b.u32(t.cfg.timescale);
-        b.u32(t.t.media_duration as u32);
-    }
-    b.u16(pack_language(&t.cfg.language));
-    b.u16(0);
-    b.end(m);
-    let (htype, default_name) = match t.handler {
-        Handler::Video => (b"vide", "VideoHandler"),
-        Handler::Audio => (b"soun", "SoundHandler"),
-        Handler::Timecode => (b"tmcd", "TimeCodeHandler"),
-        Handler::Other => (b"meta", "MetaHandler"),
-    };
-    let name = t.cfg.handler_name.clone().unwrap_or_else(|| default_name.into());
-    let m = b.start_full(b"hdlr", 0, 0);
-    b.bytes(if qt { b"mhlr" } else { &[0, 0, 0, 0] });
-    b.bytes(htype);
-    b.zeros(12);
-    if qt {
-        let n = name.len().min(255);
-        b.u8(n as u8);
-        b.bytes(&name.as_bytes()[..n]);
-    } else {
-        b.bytes(name.as_bytes());
-        b.u8(0);
-    }
-    b.end(m);
-    let minf = b.start(b"minf");
-    match t.handler {
-        Handler::Video => {
-            let m = b.start_full(b"vmhd", 0, 1);
-            b.zeros(8);
-            b.end(m);
-        }
-        Handler::Audio => {
-            let m = b.start_full(b"smhd", 0, 0);
-            b.zeros(4);
-            b.end(m);
-        }
-        Handler::Timecode => {
-            let g = b.start(b"gmhd");
-            let m = b.start_full(b"gmin", 0, 0);
-            b.u16(0x40);
-            b.u16(0x8000);
-            b.u16(0x8000);
-            b.u16(0x8000);
-            b.i16(0);
-            b.u16(0);
-            b.end(m);
-            let tm = b.start(b"tmcd");
-            let m = b.start_full(b"tcmi", 0, 0);
-            b.u16(0);
-            b.u16(0);
-            b.u16(12);
-            b.u16(0);
-            b.bytes(&[0xFF; 6]);
-            b.zeros(6);
-            b.u8(0);
-            b.end(m);
-            b.end(tm);
-            b.end(g);
-        }
-        Handler::Other => {
-            let m = b.start_full(b"nmhd", 0, 0);
-            b.end(m);
-        }
-    }
-    if qt {
-        // QuickTime data handler reference.
-        let m = b.start_full(b"hdlr", 0, 0);
-        b.bytes(b"dhlr");
-        b.bytes(b"url ");
-        b.zeros(12);
-        b.u8(0);
-        b.end(m);
-    }
-    let d = b.start(b"dinf");
-    let r = b.start_full(b"dref", 0, 0);
-    b.u32(1);
-    let u = b.start_full(b"url ", 0, 1);
-    b.end(u);
-    b.end(r);
-    b.end(d);
-    let stbl = b.start(b"stbl");
-    let m = b.start_full(b"stsd", 0, 0);
-    b.u32(1);
-    t.cfg.entry.write(b, qt)?;
-    b.end(m);
-    let tb = &t.t;
-    let m = b.start_full(b"stts", 0, 0);
-    b.u32(tb.stts.len() as u32);
-    for &(c, d) in &tb.stts {
-        b.u32(c);
-        b.u32(d);
-    }
-    b.end(m);
-    if tb.ctts.iter().any(|&(_, o)| o != 0) {
-        let neg = tb.ctts.iter().any(|&(_, o)| o < 0);
-        let m = b.start_full(b"ctts", neg as u8, 0);
-        b.u32(tb.ctts.len() as u32);
-        for &(c, o) in &tb.ctts {
-            b.u32(c);
-            b.i32(o);
-        }
-        b.end(m);
-    }
-    if !tb.all_sync {
-        let m = b.start_full(b"stss", 0, 0);
-        b.u32(tb.sync.len() as u32);
-        for &s in &tb.sync {
-            b.u32(s);
-        }
-        b.end(m);
-    }
-    let m = b.start_full(b"stsc", 0, 0);
-    let mut runs: Vec<(u32, u32)> = Vec::new();
-    for (i, &(_, n)) in tb.chunks.iter().enumerate() {
-        if runs.last().is_none_or(|r| r.1 != n) {
-            runs.push((i as u32 + 1, n));
-        }
-    }
-    b.u32(runs.len() as u32);
-    for (first, n) in runs {
-        b.u32(first);
-        b.u32(n);
-        b.u32(1);
-    }
-    b.end(m);
-    let m = b.start_full(b"stsz", 0, 0);
-    match tb.const_size {
-        Some(s) => {
-            b.u32(s);
-            b.u32(tb.sample_count.min(u32::MAX as u64) as u32);
-        }
-        None => {
-            let first = tb.sizes.first().copied().unwrap_or(0);
-            // A uniform size of 0 would mean "table follows" (ISO/IEC 14496-12 §8.7.3), so
-            // all-empty samples must still be written as a table.
-            if first != 0 && !tb.sizes.is_empty() && tb.sizes.iter().all(|&s| s == first) {
-                b.u32(first);
-                b.u32(tb.sizes.len() as u32);
-            } else {
-                b.u32(0);
-                b.u32(tb.sizes.len() as u32);
-                for &s in &tb.sizes {
-                    b.u32(s);
-                }
-            }
-        }
-    }
-    b.end(m);
-    let co64 = force_co64 || tb.chunks.iter().any(|&(o, _)| o + shift > u32::MAX as u64);
-    let m = b.start_full(if co64 { b"co64" } else { b"stco" }, 0, 0);
-    b.u32(tb.chunks.len() as u32);
-    for &(o, _) in &tb.chunks {
-        if co64 {
-            b.u64(o + shift);
-        } else {
-            b.u32((o + shift) as u32);
-        }
-    }
-    b.end(m);
-    b.end(stbl);
-    b.end(minf);
-    b.end(mdia);
-    b.end(trak);
-    Ok(())
-}
-
-fn write_udta(b: &mut BoxBuf, md: &[(String, String)]) {
-    let items: Vec<([u8; 4], &str)> = md
-        .iter()
-        .filter_map(|(k, v)| {
-            let mut chars = k.chars();
-            if chars.next()? != '©' {
-                return None;
-            }
-            let rest: Vec<u8> = chars.map(|c| c as u32 as u8).collect();
-            (rest.len() == 3).then(|| ([0xA9, rest[0], rest[1], rest[2]], v.as_str()))
-        })
-        .collect();
-    if items.is_empty() {
-        return;
-    }
-    let u = b.start(b"udta");
-    for (k, v) in items {
-        let m = b.start(&k);
-        b.u16(v.len() as u16);
-        b.u16(0x55C4);
-        b.bytes(v.as_bytes());
-        b.end(m);
-    }
-    b.end(u);
-}
-
-fn validate_track(cfg: &TrackConfig) -> Result<Option<u32>> {
-    if cfg.timescale == 0 {
-        return Err(Error::Mux("timescale must be non-zero".into()));
-    }
-    if let CodecConfig::Pcm(p) = &cfg.entry.codec {
-        if p.bits == 0 || p.channels == 0 {
-            return Err(Error::Mux("PCM needs bits and channels".into()));
-        }
-        if (p.sample_rate - cfg.timescale as f64).abs() > 0.5 {
-            return Err(Error::Mux("PCM track timescale must equal the sample rate".into()));
-        }
-        let Some(n) = p.bytes_per_frame() else {
-            return Err(Error::Mux("PCM frame size overflows".into()));
-        };
-        return Ok(Some(n));
-    }
-    Ok(None)
-}
-
-/// Progressive MP4/MOV writer: `ftyp`, then one `mdat` streamed to `W`, then `moov` at [`finish`](Self::finish)
-/// (or moved in front of `mdat` by [`finish_faststart`](Self::finish_faststart)).
-pub struct Mp4Writer<W: Write + Seek> {
-    w: W,
-    opts: WriterOptions,
-    tracks: Vec<WTrack>,
-    /// Offset of the placeholder box (8 bytes) preceding the mdat header.
-    pad_pos: u64,
-    mdat_pos: u64,
-    pos: u64,
-    last_track: Option<usize>,
-}
-
-impl<W: Write + Seek> Mp4Writer<W> {
-    /// Start a file: writes `ftyp`, a placeholder box and the `mdat` header.
-    pub fn new(mut w: W, opts: WriterOptions) -> Result<Self> {
-        let start = w.stream_position()?;
-        let mut b = BoxBuf::new();
-        write_ftyp(&mut b, opts.brand);
-        let pad_pos = start + b.len() as u64;
-        b.leaf(if opts.brand == Brand::Mov { b"wide" } else { b"free" }, &[]);
-        let mdat_pos = start + b.len() as u64;
-        b.leaf(b"mdat", &[]);
-        w.write_all(&b.buf)?;
-        let pos = start + b.len() as u64;
-        Ok(Mp4Writer { w, opts, tracks: Vec::new(), pad_pos, mdat_pos, pos, last_track: None })
-    }
-
-    /// Add a track; returns its index (track ids are index + 1).
-    pub fn add_track(&mut self, cfg: TrackConfig) -> Result<usize> {
-        let pcm = validate_track(&cfg)?;
-        let handler = handler_of(&cfg.entry);
-        let mut t = Tables::new();
-        t.const_size = pcm;
-        self.tracks.push(WTrack { id: self.tracks.len() as u32 + 1, handler, pcm_frame_bytes: pcm, t, cfg, tmcd_ref: None, tmcd_source: None });
-        Ok(self.tracks.len() - 1)
-    }
-
-    /// Add a QuickTime timecode track referenced by `video_track`. Its single sample (the start
-    /// frame number) is written at finish, spanning the video track's duration.
-    pub fn add_timecode_track(&mut self, video_track: usize, tc: TimecodeConfig, start_frame: u32) -> Result<usize> {
-        if video_track >= self.tracks.len() {
-            return Err(Error::NoSuchTrack(video_track));
-        }
-        if tc.timescale == 0 || tc.frame_duration == 0 || tc.frames_per_second == 0 {
-            return Err(Error::Mux("timecode needs timescale, frame duration and fps".into()));
-        }
-        let entry = SampleEntry {
-            format: crate::bytes::FourCc(*b"tmcd"),
-            data_reference_index: 1,
-            codec: CodecConfig::Timecode(tc.clone()),
-            video: None,
-            audio: None,
-            bitrate: None,
-        };
-        let idx = self.add_track(TrackConfig::new(entry, tc.timescale))?;
-        self.tracks[idx].tmcd_source = Some((video_track, start_frame));
-        let id = self.tracks[idx].id;
-        self.tracks[video_track].tmcd_ref = Some(id);
-        Ok(idx)
-    }
-
-    /// Append one sample to track `track` (decode order). For PCM tracks `data` may hold any whole
-    /// number of audio frames.
-    pub fn write_sample(&mut self, track: usize, s: WriteSample) -> Result<()> {
-        let tr = self.tracks.get(track).ok_or(Error::NoSuchTrack(track))?;
-        if tr.tmcd_source.is_some() {
-            return Err(Error::Mux("timecode track samples are written automatically".into()));
-        }
-        let (count, dur) = match tr.pcm_frame_bytes {
-            Some(fb) => {
-                if !s.data.len().is_multiple_of(fb as usize) {
-                    return Err(Error::Mux("PCM data is not a whole number of frames".into()));
-                }
-                ((s.data.len() / fb as usize) as u32, 1u32)
-            }
-            None => {
-                if s.data.len() > u32::MAX as usize {
-                    return Err(Error::Mux("sample larger than 4 GiB".into()));
-                }
-                (1, s.duration)
-            }
-        };
-        if count == 0 {
-            return Ok(());
-        }
-        self.w.write_all(s.data)?;
-        let offset = self.pos;
-        self.pos += s.data.len() as u64;
-        let contiguous = self.last_track == Some(track);
-        self.last_track = Some(track);
-        let tr = &mut self.tracks[track];
-        let t = &mut tr.t;
-        Tables::push_run(&mut t.stts, count, dur);
-        Tables::push_run(&mut t.ctts, count, if tr.pcm_frame_bytes.is_some() { 0 } else { s.composition_offset });
-        if tr.pcm_frame_bytes.is_none() {
-            t.sizes.push(s.data.len() as u32);
-            if s.is_sync {
-                t.sync.push(t.sample_count as u32 + 1);
-            } else {
-                t.all_sync = false;
-            }
-        }
-        t.sample_count += count as u64;
-        let ct = if tr.pcm_frame_bytes.is_some() { 0 } else { s.composition_offset as i64 };
-        t.comp_end = t.comp_end.max((t.media_duration as i64 + ct + count as i64 * dur as i64).max(0) as u64);
-        t.media_duration += count as u64 * dur as u64;
-        match t.chunks.last_mut() {
-            Some(c) if contiguous => c.1 += count,
-            _ => t.chunks.push((offset, count)),
-        }
-        Ok(())
-    }
-
-    fn finish_mdat(&mut self) -> Result<()> {
-        // Timecode samples.
-        for i in 0..self.tracks.len() {
-            let Some((vi, start)) = self.tracks[i].tmcd_source else { continue };
-            let v = &self.tracks[vi];
-            let vd = v.t.media_duration;
-            let vts = v.cfg.timescale;
-            let tts = self.tracks[i].cfg.timescale;
-            let tc_dur = match &self.tracks[i].cfg.entry.codec {
-                CodecConfig::Timecode(tc) => tc.frame_duration,
-                _ => 1,
-            };
-            let d = rescale(vd, vts, tts).max(tc_dur as u64).min(u32::MAX as u64) as u32;
-            self.w.write_all(&start.to_be_bytes())?;
-            let off = self.pos;
-            self.pos += 4;
-            self.last_track = None;
-            let t = &mut self.tracks[i].t;
-            t.stts.push((1, d));
-            t.sizes.push(4);
-            t.sync.push(1);
-            t.sample_count = 1;
-            t.media_duration = d as u64;
-            t.chunks.push((off, 1));
-        }
-        let size = self.pos - self.mdat_pos;
-        if size <= u32::MAX as u64 {
-            self.w.seek(SeekFrom::Start(self.mdat_pos))?;
-            self.w.write_all(&(size as u32).to_be_bytes())?;
-        } else {
-            // Merge the placeholder into a 16-byte large-size mdat header.
-            let mut h = [0u8; 16];
-            h[..4].copy_from_slice(&1u32.to_be_bytes());
-            h[4..8].copy_from_slice(b"mdat");
-            h[8..].copy_from_slice(&(self.pos - self.pad_pos).to_be_bytes());
-            self.w.seek(SeekFrom::Start(self.pad_pos))?;
-            self.w.write_all(&h)?;
-        }
-        self.w.seek(SeekFrom::Start(self.pos))?;
-        Ok(())
-    }
-
-    fn build_moov(&self, shift: u64, force_co64: bool) -> Result<Vec<u8>> {
-        let qt = self.opts.brand == Brand::Mov;
-        let ts = self.opts.movie_timescale.max(1);
-        let mut b = BoxBuf::new();
-        let m = b.start(b"moov");
-        write_mvhd(&mut b, ts, movie_duration(&self.tracks, ts), self.tracks.len() as u32 + 1);
-        for t in &self.tracks {
-            write_trak(&mut b, t, ts, qt, shift, force_co64)?;
-        }
-        write_udta(&mut b, &self.opts.metadata);
-        b.end(m);
-        Ok(b.buf)
-    }
-
-    /// Finish the file with `moov` after `mdat`. Returns the underlying writer.
-    pub fn finish(mut self) -> Result<W> {
-        self.finish_mdat()?;
-        let moov = self.build_moov(0, false)?;
-        self.w.write_all(&moov)?;
-        self.w.flush()?;
-        Ok(self.w)
-    }
-}
-
-impl<W: Read + Write + Seek> Mp4Writer<W> {
-    /// Finish with `moov` in front of `mdat` ("fast start"): media data is shifted forward in place.
-    pub fn finish_faststart(mut self) -> Result<W> {
-        self.finish_mdat()?;
-        let mut moov = self.build_moov(0, false)?;
-        let mut force = false;
-        loop {
-            let shift = moov.len() as u64;
-            let next = self.build_moov(shift, force)?;
-            if next.len() == moov.len() {
-                moov = next;
-                break;
-            }
-            // Offsets crossed the 32-bit boundary: switch to co64 (size only grows, so this converges).
-            force = true;
-            moov = next;
-        }
-        let shift = moov.len() as u64;
-        let start = self.pad_pos;
-        let end = self.pos;
-        let mut buf = vec![0u8; 1 << 20];
-        let mut cur = end;
-        while cur > start {
-            let n = (cur - start).min(buf.len() as u64) as usize;
-            cur -= n as u64;
-            self.w.seek(SeekFrom::Start(cur))?;
-            self.w.read_exact(&mut buf[..n])?;
-            self.w.seek(SeekFrom::Start(cur + shift))?;
-            self.w.write_all(&buf[..n])?;
-        }
-        self.w.seek(SeekFrom::Start(start))?;
-        self.w.write_all(&moov)?;
-        self.w.seek(SeekFrom::Start(end + shift))?;
-        self.w.flush()?;
-        Ok(self.w)
-    }
-}
-
-/// Buffered fragment sample: (data, duration, composition offset, sync).
-type PendingSample = (Vec<u8>, u32, i32, bool);
-
-/// Fragmented MP4 writer: an init segment (`ftyp` + `moov` with `mvex`) followed by
-/// `moof`+`mdat` fragments. Samples are buffered until [`flush_fragment`](Self::flush_fragment).
-pub struct FragmentedWriter<W: Write> {
-    w: W,
-    opts: WriterOptions,
-    tracks: Vec<WTrack>,
-    pending: Vec<Vec<PendingSample>>,
-    next_dts: Vec<u64>,
-    seq: u32,
-    init_written: bool,
-}
-
-impl<W: Write> FragmentedWriter<W> {
-    pub fn new(w: W, opts: WriterOptions) -> Self {
-        FragmentedWriter { w, opts, tracks: Vec::new(), pending: Vec::new(), next_dts: Vec::new(), seq: 0, init_written: false }
-    }
-
-    /// Add a track (before the first fragment). PCM is not supported in fragments.
-    pub fn add_track(&mut self, cfg: TrackConfig) -> Result<usize> {
-        if self.init_written {
-            return Err(Error::Mux("tracks must be added before the first fragment".into()));
-        }
-        if validate_track(&cfg)?.is_some() {
-            return Err(Error::Mux("PCM is not supported by the fragmented writer".into()));
-        }
-        let handler = handler_of(&cfg.entry);
-        self.tracks.push(WTrack {
-            id: self.tracks.len() as u32 + 1,
-            handler,
-            pcm_frame_bytes: None,
-            t: Tables::new(),
-            cfg,
-            tmcd_ref: None,
-            tmcd_source: None,
-        });
-        self.pending.push(Vec::new());
-        self.next_dts.push(0);
-        Ok(self.tracks.len() - 1)
-    }
-
-    fn write_init(&mut self) -> Result<()> {
-        let qt = self.opts.brand == Brand::Mov;
-        let ts = self.opts.movie_timescale.max(1);
-        let mut b = BoxBuf::new();
-        write_ftyp(&mut b, self.opts.brand);
-        let m = b.start(b"moov");
-        write_mvhd(&mut b, ts, 0, self.tracks.len() as u32 + 1);
-        for t in &self.tracks {
-            write_trak(&mut b, t, ts, qt, 0, false)?;
-        }
-        let mv = b.start(b"mvex");
-        for t in &self.tracks {
-            let x = b.start_full(b"trex", 0, 0);
-            b.u32(t.id);
-            b.u32(1);
-            b.u32(0);
-            b.u32(0);
-            b.u32(0);
-            b.end(x);
-        }
-        b.end(mv);
-        write_udta(&mut b, &self.opts.metadata);
-        b.end(m);
-        self.w.write_all(&b.buf)?;
-        self.init_written = true;
-        Ok(())
-    }
-
-    /// Buffer a sample for the next fragment.
-    pub fn write_sample(&mut self, track: usize, s: WriteSample) -> Result<()> {
-        let p = self.pending.get_mut(track).ok_or(Error::NoSuchTrack(track))?;
-        if s.data.len() > u32::MAX as usize {
-            return Err(Error::Mux("sample larger than 4 GiB".into()));
-        }
-        p.push((s.data.to_vec(), s.duration, s.composition_offset, s.is_sync));
-        Ok(())
-    }
-
-    fn build_moof(&self, data_offsets: &[i32]) -> Vec<u8> {
-        let mut b = BoxBuf::new();
-        let m = b.start(b"moof");
-        let h = b.start_full(b"mfhd", 0, 0);
-        b.u32(self.seq);
-        b.end(h);
-        for (i, t) in self.tracks.iter().enumerate() {
-            let p = &self.pending[i];
-            if p.is_empty() {
-                continue;
-            }
-            let tf = b.start(b"traf");
-            let h = b.start_full(b"tfhd", 0, 0x20000);
-            b.u32(t.id);
-            b.end(h);
-            let h = b.start_full(b"tfdt", 1, 0);
-            b.u64(self.next_dts[i]);
-            b.end(h);
-            let neg = p.iter().any(|s| s.2 < 0);
-            let h = b.start_full(b"trun", neg as u8, 0x1 | 0x100 | 0x200 | 0x400 | 0x800);
-            b.u32(p.len() as u32);
-            b.i32(data_offsets[i]);
-            for (d, dur, cto, sync) in p {
-                b.u32(*dur);
-                b.u32(d.len() as u32);
-                b.u32(if *sync { 0x0200_0000 } else { 0x0101_0000 });
-                b.i32(*cto);
-            }
-            b.end(h);
-            b.end(tf);
-        }
-        b.end(m);
-        b.buf
-    }
-
-    /// Write all buffered samples as one `moof` + `mdat` fragment (no-op if nothing is buffered).
-    pub fn flush_fragment(&mut self) -> Result<()> {
-        if !self.init_written {
-            self.write_init()?;
-        }
-        if self.pending.iter().all(|p| p.is_empty()) {
-            return Ok(());
-        }
-        self.seq += 1;
-        let probe = self.build_moof(&vec![0; self.tracks.len()]);
-        let data_len: u64 = self.pending.iter().flatten().map(|s| s.0.len() as u64).sum();
-        let large = data_len + 8 > u32::MAX as u64;
-        let hdr = if large { 16 } else { 8 };
-        let mut offs = Vec::with_capacity(self.tracks.len());
-        let mut acc = probe.len() as u64 + hdr;
-        for p in &self.pending {
-            offs.push(i32::try_from(acc).map_err(|_| Error::Mux("fragment too large".into()))?);
-            acc += p.iter().map(|s| s.0.len() as u64).sum::<u64>();
-        }
-        let moof = self.build_moof(&offs);
-        self.w.write_all(&moof)?;
-        if large {
-            self.w.write_all(&1u32.to_be_bytes())?;
-            self.w.write_all(b"mdat")?;
-            self.w.write_all(&(data_len + 16).to_be_bytes())?;
-        } else {
-            self.w.write_all(&((data_len + 8) as u32).to_be_bytes())?;
-            self.w.write_all(b"mdat")?;
-        }
-        for (i, p) in self.pending.iter_mut().enumerate() {
-            for (d, dur, _, _) in p.drain(..) {
-                self.w.write_all(&d)?;
-                self.next_dts[i] += dur as u64;
-            }
-        }
-        Ok(())
-    }
-
-    /// Flush remaining samples and return the writer.
-    pub fn finish(mut self) -> Result<W> {
-        self.flush_fragment()?;
-        self.w.flush()?;
-        Ok(self.w)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::codec::{AvcConfig, PcmConfig};
-    use std::io::Cursor;
-
-    fn avc_entry() -> SampleEntry {
-        SampleEntry::avc(AvcConfig::new(vec![vec![0x67, 0x42, 0, 0x1E]], vec![vec![0x68, 0xCE]], 4), 64, 48)
-    }
-
-    #[test]
-    fn language_pack() {
-        assert_eq!(pack_language("und"), 0x55C4);
-        assert_eq!(pack_language("eng"), 0x15C7);
-        assert_eq!(pack_language("EN"), 0x55C4);
-    }
-
-    #[test]
-    fn simple_roundtrip_and_faststart() {
-        for fast in [false, true] {
-            let mut w = Mp4Writer::new(Cursor::new(Vec::new()), WriterOptions::new(Brand::Mp4)).unwrap();
-            let v = w.add_track(TrackConfig::new(avc_entry(), 12800)).unwrap();
-            let pcm = PcmConfig { bits: 16, float: false, big_endian: false, signed: true, channels: 2, sample_rate: 48000.0 };
-            let a = w.add_track(TrackConfig::new(SampleEntry::pcm(pcm), 48000)).unwrap();
-            for i in 0..10u8 {
-                let data = vec![i; 100 + i as usize];
-                w.write_sample(
-                    v,
-                    WriteSample { data: &data, duration: 512, composition_offset: if i % 2 == 0 { 1024 } else { 0 }, is_sync: i % 5 == 0 },
-                )
-                .unwrap();
-                w.write_sample(a, WriteSample { data: &[i; 400], duration: 0, composition_offset: 0, is_sync: true }).unwrap();
-            }
-            let out = if fast { w.finish_faststart() } else { w.finish() }.unwrap().into_inner();
-            let f = crate::open(out.as_slice()).unwrap();
-            assert_eq!(f.tracks.len(), 2);
-            let t = &f.tracks[0];
-            assert_eq!(t.samples.len(), 10);
-            for (i, s) in t.samples.iter().enumerate() {
-                assert_eq!(s.size as usize, 100 + i);
-                assert_eq!(s.dts, 512 * i as i64);
-                assert_eq!(s.is_sync, i % 5 == 0);
-                assert_eq!(f.read_sample(out.as_slice(), 0, i).unwrap(), vec![i as u8; 100 + i]);
-            }
-            let at = &f.tracks[1];
-            assert!(at.pcm_chunked);
-            assert_eq!(at.samples.len(), 10);
-            assert_eq!(at.samples[3].size, 400);
-            assert_eq!(at.samples[3].duration, 100);
-            assert_eq!(f.read_sample(out.as_slice(), 1, 3).unwrap(), vec![3u8; 400]);
-            if fast {
-                assert!(f.moov_offset < t.samples[0].offset);
-            }
-        }
-    }
-
-    #[test]
-    fn fragmented_roundtrip() {
-        let mut w = FragmentedWriter::new(Vec::new(), WriterOptions::new(Brand::Mp4));
-        let v = w.add_track(TrackConfig::new(avc_entry(), 1000)).unwrap();
-        for i in 0..6u8 {
-            w.write_sample(v, WriteSample { data: &[i; 10], duration: 40, composition_offset: -(i as i32 % 2), is_sync: i % 3 == 0 }).unwrap();
-            if i % 3 == 2 {
-                w.flush_fragment().unwrap();
-            }
-        }
-        let out = w.finish().unwrap();
-        let f = crate::open(out.as_slice()).unwrap();
-        assert!(f.fragmented);
-        assert_eq!(f.fragment_count, 2);
-        let t = &f.tracks[0];
-        assert_eq!(t.samples.len(), 6);
-        for (i, s) in t.samples.iter().enumerate() {
-            assert_eq!(s.dts, 40 * i as i64);
-            assert_eq!(s.pts, s.dts - (i as i64 % 2));
-            assert_eq!(s.is_sync, i % 3 == 0);
-            assert_eq!(f.read_sample(out.as_slice(), 0, i).unwrap(), vec![i as u8; 10]);
-        }
-        assert_eq!(t.sync_sample_before(5), 3);
-    }
-}
@@ -1,123 +0,0 @@
-//! Random-access byte sources for the demuxer.
-
-use std::io;
-use std::sync::Arc;
-
-/// Random-access, read-only byte source (file, in-memory buffer, web Blob…).
-///
-/// Implementations must be able to serve reads at arbitrary offsets through `&self`.
-pub trait ByteSource {
-    /// Total length in bytes.
-    fn len(&self) -> u64;
-    /// Fill `buf` entirely with bytes starting at `offset`; fail with `UnexpectedEof` if past the end.
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()>;
-    /// True if the source holds no bytes.
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-}
-
-fn eof() -> io::Error {
-    io::Error::new(io::ErrorKind::UnexpectedEof, "read past end of byte source")
-}
-
-impl ByteSource for [u8] {
-    fn len(&self) -> u64 {
-        <[u8]>::len(self) as u64
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        let start = usize::try_from(offset).map_err(|_| eof())?;
-        let end = start.checked_add(buf.len()).ok_or_else(eof)?;
-        let src = self.get(start..end).ok_or_else(eof)?;
-        buf.copy_from_slice(src);
-        Ok(())
-    }
-}
-
-impl ByteSource for Vec<u8> {
-    fn len(&self) -> u64 {
-        self.as_slice().len() as u64
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        self.as_slice().read_at(offset, buf)
-    }
-}
-
-impl<T: ByteSource + ?Sized> ByteSource for &T {
-    fn len(&self) -> u64 {
-        (**self).len()
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_at(offset, buf)
-    }
-}
-
-impl<T: ByteSource + ?Sized> ByteSource for Arc<T> {
-    fn len(&self) -> u64 {
-        (**self).len()
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_at(offset, buf)
-    }
-}
-
-impl<T: ByteSource + ?Sized> ByteSource for Box<T> {
-    fn len(&self) -> u64 {
-        (**self).len()
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_at(offset, buf)
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl ByteSource for std::fs::File {
-    fn len(&self) -> u64 {
-        self.metadata().map(|m| m.len()).unwrap_or(0)
-    }
-    #[cfg(unix)]
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        std::os::unix::fs::FileExt::read_exact_at(self, buf, offset)
-    }
-    #[cfg(windows)]
-    fn read_at(&self, mut offset: u64, mut buf: &mut [u8]) -> io::Result<()> {
-        use std::os::windows::fs::FileExt;
-        while !buf.is_empty() {
-            let n = self.seek_read(buf, offset)?;
-            if n == 0 {
-                return Err(eof());
-            }
-            offset += n as u64;
-            buf = &mut buf[n..];
-        }
-        Ok(())
-    }
-    #[cfg(not(any(unix, windows)))]
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        use std::io::{Read, Seek, SeekFrom};
-        let mut f = self;
-        f.seek(SeekFrom::Start(offset))?;
-        f.read_exact(buf)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn slice_reads() {
-        let v = vec![1u8, 2, 3, 4];
-        let mut b = [0u8; 2];
-        v.read_at(1, &mut b).unwrap();
-        assert_eq!(b, [2, 3]);
-        assert!(v.read_at(3, &mut b).is_err());
-        assert!(v.read_at(u64::MAX, &mut b).is_err());
-        let a: Arc<[u8]> = Arc::from(v.clone());
-        a.read_at(2, &mut b).unwrap();
-        assert_eq!(b, [3, 4]);
-        assert_eq!(ByteSource::len(&a), 4);
-        let s: &[u8] = &v;
-        assert_eq!(ByteSource::len(&s), 4);
-    }
-}
@@ -10,3 +10,4 @@ rust-version.workspace = true
 workspace = true

 [dependencies]
+craft-media = { workspace = true, features = ["matroska"] }
@@ -1,225 +0,0 @@
-//! Matroska CodecID → codec mapping (Matroska codec specifications, RFC 9559 §5.1.4.1.21 and the
-//! codec mappings registry).
-
-/// Codec of a track, derived from `CodecID` and `CodecPrivate`.
-///
-/// Configuration records are passed through as the raw bytes found in `CodecPrivate`, which for
-/// the ISO codecs are exactly the ISOBMFF configuration boxes' payloads (avcC, hvcC, av1C, ASC…).
-#[derive(Clone, Debug, PartialEq)]
-pub enum Codec {
-    /// `V_MPEG4/ISO/AVC`; payload is an `AVCDecoderConfigurationRecord` (avcC).
-    Avc { avcc: Vec<u8> },
-    /// `V_MPEGH/ISO/HEVC`; payload is an `HEVCDecoderConfigurationRecord` (hvcC).
-    Hevc { hvcc: Vec<u8> },
-    /// `V_VP8`.
-    Vp8,
-    /// `V_VP9`; `CodecPrivate` (optional) holds VP9 codec feature metadata.
-    Vp9 { private: Vec<u8> },
-    /// `V_AV1`; payload is an `AV1CodecConfigurationRecord` (av1C).
-    Av1 { av1c: Vec<u8> },
-    /// `V_PRORES`; `fourcc` from `CodecPrivate` (e.g. `apcn`), if present.
-    ProRes { fourcc: Option<[u8; 4]> },
-    /// `V_MJPEG`, or `V_MS/VFW/FOURCC` with an `MJPG` compression FourCC.
-    Mjpeg,
-    /// `V_MS/VFW/FOURCC` with any other FourCC; `bitmap_info_header` is the whole `CodecPrivate`.
-    VfwFourcc { fourcc: [u8; 4], bitmap_info_header: Vec<u8> },
-    /// `A_AAC` (and the legacy `A_AAC/MPEG{2,4}/<profile>` IDs); `asc` is the
-    /// `AudioSpecificConfig` (synthesised for legacy IDs without `CodecPrivate`).
-    Aac { asc: Vec<u8> },
-    /// `A_OPUS`; `head` is the `OpusHead` identification header.
-    Opus { head: Vec<u8> },
-    /// `A_VORBIS`; the three Vorbis headers (identification, comment, setup), split from the
-    /// Xiph-laced `CodecPrivate`.
-    Vorbis { headers: Vec<Vec<u8>> },
-    /// `A_FLAC`; `private` is `fLaC` + metadata blocks (STREAMINFO first).
-    Flac { private: Vec<u8> },
-    /// `A_PCM/INT/LIT`, `A_PCM/INT/BIG`, `A_PCM/FLOAT/IEEE`. Bit depth comes from the Audio element.
-    Pcm { float: bool, big_endian: bool, bits: u16 },
-    /// `A_AC3`.
-    Ac3,
-    /// `A_EAC3`.
-    Eac3,
-    /// `A_MPEG/L3`.
-    Mp3,
-    /// `A_MPEG/L2`.
-    Mp2,
-    /// `S_TEXT/UTF8` (SubRip-style plain text).
-    SubRip,
-    /// `S_TEXT/WEBVTT`, or WebM's `D_WEBVTT/{SUBTITLES,CAPTIONS,DESCRIPTIONS,METADATA}`.
-    WebVtt,
-    /// `S_TEXT/ASS` / `S_TEXT/SSA`; `header` is the script header from `CodecPrivate`.
-    Ass { header: Vec<u8>, ssa: bool },
-    /// Any other CodecID (kept verbatim along with `Track::codec_private`).
-    Other(String),
-}
-
-impl Codec {
-    /// Short codec name, matching FFmpeg's `codec_name` where one exists (useful for logs/UI).
-    pub fn name(&self) -> String {
-        match self {
-            Codec::Avc { .. } => "h264".into(),
-            Codec::Hevc { .. } => "hevc".into(),
-            Codec::Vp8 => "vp8".into(),
-            Codec::Vp9 { .. } => "vp9".into(),
-            Codec::Av1 { .. } => "av1".into(),
-            Codec::ProRes { .. } => "prores".into(),
-            Codec::Mjpeg => "mjpeg".into(),
-            Codec::VfwFourcc { fourcc, .. } => String::from_utf8_lossy(fourcc).trim().to_ascii_lowercase(),
-            Codec::Aac { .. } => "aac".into(),
-            Codec::Opus { .. } => "opus".into(),
-            Codec::Vorbis { .. } => "vorbis".into(),
-            Codec::Flac { .. } => "flac".into(),
-            Codec::Pcm { float, big_endian, bits } => {
-                let k = if *float {
-                    'f'
-                } else if *bits == 8 {
-                    'u'
-                } else {
-                    's'
-                };
-                if *bits == 8 { format!("pcm_{k}8") } else { format!("pcm_{k}{bits}{}", if *big_endian { "be" } else { "le" }) }
-            }
-            Codec::Ac3 => "ac3".into(),
-            Codec::Eac3 => "eac3".into(),
-            Codec::Mp3 => "mp3".into(),
-            Codec::Mp2 => "mp2".into(),
-            Codec::SubRip => "subrip".into(),
-            Codec::WebVtt => "webvtt".into(),
-            Codec::Ass { ssa, .. } => if *ssa { "ssa" } else { "ass" }.into(),
-            Codec::Other(id) => id.clone(),
-        }
-    }
-}
-
-const AAC_RATES: [u32; 13] = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
-
-/// Build a 2-byte (or 5-byte with SBR extension) AudioSpecificConfig for legacy `A_AAC/...` IDs.
-fn synth_asc(object_type: u8, rate: f64, out_rate: Option<f64>, channels: u64, sbr: bool) -> Vec<u8> {
-    let rate_index = |r: f64| AAC_RATES.iter().position(|&x| x as f64 == r).unwrap_or(4) as u8;
-    let ri = rate_index(rate);
-    let ch = channels.min(7) as u8;
-    let mut v = vec![(object_type << 3) | (ri >> 1), ((ri & 1) << 7) | (ch << 3)];
-    if sbr {
-        // backward-compatible explicit signalling: sync 0x2b7, SBR object type 5, flag, ext rate index
-        let ext = rate_index(out_rate.unwrap_or(rate * 2.0));
-        v.push(0x56);
-        v.push(0xE5);
-        v.push(0x80 | (ext << 3));
-    }
-    v
-}
-
-/// Split a Xiph-laced `CodecPrivate` (Vorbis/Theora headers).
-fn split_xiph(p: &[u8]) -> Vec<Vec<u8>> {
-    let Some(&n) = p.first() else { return Vec::new() };
-    let mut pos = 1;
-    let mut sizes = Vec::new();
-    for _ in 0..n {
-        let mut s = 0usize;
-        loop {
-            let Some(&b) = p.get(pos) else { return Vec::new() };
-            pos += 1;
-            s += b as usize;
-            if b != 255 {
-                break;
-            }
-        }
-        sizes.push(s);
-    }
-    let mut out = Vec::new();
-    for s in sizes {
-        let Some(h) = p.get(pos..pos + s) else { return Vec::new() };
-        out.push(h.to_vec());
-        pos += s;
-    }
-    out.push(p[pos.min(p.len())..].to_vec());
-    out
-}
-
-/// Map a CodecID + CodecPrivate (+ audio params for legacy AAC / PCM) to a [`Codec`].
-pub(crate) fn map_codec(id: &str, private: &[u8], audio: Option<&crate::AudioInfo>) -> Codec {
-    let p = private.to_vec();
-    match id {
-        "V_MPEG4/ISO/AVC" => Codec::Avc { avcc: p },
-        "V_MPEGH/ISO/HEVC" => Codec::Hevc { hvcc: p },
-        "V_VP8" => Codec::Vp8,
-        "V_VP9" => Codec::Vp9 { private: p },
-        "V_AV1" => Codec::Av1 { av1c: p },
-        "V_PRORES" => Codec::ProRes { fourcc: private.get(..4).and_then(|f| f.try_into().ok()) },
-        "V_MJPEG" => Codec::Mjpeg,
-        "V_MS/VFW/FOURCC" => {
-            let fourcc: [u8; 4] = private.get(16..20).and_then(|f| f.try_into().ok()).unwrap_or(*b"    ");
-            match &fourcc {
-                b"MJPG" | b"mjpg" | b"AVRn" | b"AVDJ" => Codec::Mjpeg,
-                b"H264" | b"h264" | b"avc1" | b"X264" | b"x264" => Codec::Avc { avcc: Vec::new() },
-                b"apch" | b"apcn" | b"apcs" | b"apco" | b"ap4h" | b"ap4x" => Codec::ProRes { fourcc: Some(fourcc) },
-                _ => Codec::VfwFourcc { fourcc, bitmap_info_header: p },
-            }
-        }
-        "A_AAC" => Codec::Aac { asc: p },
-        "A_OPUS" => Codec::Opus { head: p },
-        "A_VORBIS" => Codec::Vorbis { headers: split_xiph(private) },
-        "A_FLAC" => Codec::Flac { private: p },
-        "A_PCM/INT/LIT" | "A_PCM/INT/BIG" | "A_PCM/FLOAT/IEEE" => {
-            let bits = audio.and_then(|a| a.bit_depth).unwrap_or(if id == "A_PCM/FLOAT/IEEE" { 32 } else { 16 }) as u16;
-            Codec::Pcm { float: id == "A_PCM/FLOAT/IEEE", big_endian: id == "A_PCM/INT/BIG", bits }
-        }
-        "A_AC3" | "A_AC3/BSID9" | "A_AC3/BSID10" => Codec::Ac3,
-        "A_EAC3" => Codec::Eac3,
-        "A_MPEG/L3" => Codec::Mp3,
-        "A_MPEG/L2" => Codec::Mp2,
-        "S_TEXT/UTF8" => Codec::SubRip,
-        "S_TEXT/WEBVTT" | "D_WEBVTT/SUBTITLES" | "D_WEBVTT/CAPTIONS" | "D_WEBVTT/DESCRIPTIONS" | "D_WEBVTT/METADATA" => Codec::WebVtt,
-        "S_TEXT/ASS" | "S_ASS" => Codec::Ass { header: p, ssa: false },
-        "S_TEXT/SSA" | "S_SSA" => Codec::Ass { header: p, ssa: true },
-        _ if id.starts_with("A_AAC/") => {
-            if !private.is_empty() {
-                return Codec::Aac { asc: p };
-            }
-            let (rate, out_rate, ch) = audio.map_or((48000.0, None, 2), |a| (a.sampling_frequency, a.output_sampling_frequency, a.channels));
-            let object_type = if id.ends_with("/MAIN") {
-                1
-            } else if id.ends_with("/SSR") {
-                3
-            } else if id.ends_with("/LTP") {
-                4
-            } else {
-                2
-            };
-            let sbr = id.ends_with("/SBR");
-            Codec::Aac { asc: synth_asc(object_type, rate, out_rate, ch, sbr) }
-        }
-        _ => Codec::Other(id.to_string()),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn mapping() {
-        assert_eq!(map_codec("V_MPEG4/ISO/AVC", &[1, 2], None), Codec::Avc { avcc: vec![1, 2] });
-        assert_eq!(map_codec("V_PRORES", b"apcn", None), Codec::ProRes { fourcc: Some(*b"apcn") });
-        let mut bih = vec![0u8; 40];
-        bih[16..20].copy_from_slice(b"MJPG");
-        assert_eq!(map_codec("V_MS/VFW/FOURCC", &bih, None), Codec::Mjpeg);
-        bih[16..20].copy_from_slice(b"FFV1");
-        assert!(matches!(map_codec("V_MS/VFW/FOURCC", &bih, None), Codec::VfwFourcc { fourcc, .. } if &fourcc == b"FFV1"));
-        let a = crate::AudioInfo { sampling_frequency: 44100.0, channels: 2, bit_depth: Some(24), output_sampling_frequency: None };
-        assert_eq!(map_codec("A_PCM/INT/LIT", &[], Some(&a)).name(), "pcm_s24le");
-        assert_eq!(map_codec("A_PCM/FLOAT/IEEE", &[], Some(&a)), Codec::Pcm { float: true, big_endian: false, bits: 24 });
-        // legacy AAC LC 44.1k stereo → 0x12 0x10
-        assert_eq!(map_codec("A_AAC/MPEG4/LC", &[], Some(&a)), Codec::Aac { asc: vec![0x12, 0x10] });
-        assert_eq!(map_codec("S_TEXT/UTF8", &[], None).name(), "subrip");
-        assert_eq!(map_codec("X_WHATEVER", &[], None), Codec::Other("X_WHATEVER".into()));
-    }
-
-    #[test]
-    fn xiph_split() {
-        let mut p = vec![2u8, 3, 2];
-        p.extend_from_slice(&[1, 1, 1, 2, 2, 3, 3, 3, 3]);
-        let h = split_xiph(&p);
-        assert_eq!(h, vec![vec![1, 1, 1], vec![2, 2], vec![3, 3, 3, 3]]);
-    }
-}
@@ -1,476 +0,0 @@
-//! EBML primitives (RFC 8794): variable-length integers, element headers, typed values, CRC-32,
-//! and Matroska block lacing (RFC 9559 §10.3).
-
-use crate::error::{Result, invalid};
-
-/// Length in bytes of a VINT whose first byte is `b` (1..=8), or `None` for a zero first byte.
-#[inline]
-pub fn vint_len(b: u8) -> Option<usize> {
-    if b == 0 { None } else { Some(b.leading_zeros() as usize + 1) }
-}
-
-/// Element data size: known, or "unknown" (all value bits set).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Size {
-    Known(u64),
-    Unknown,
-}
-
-impl Size {
-    pub fn known(self) -> Option<u64> {
-        match self {
-            Size::Known(n) => Some(n),
-            Size::Unknown => None,
-        }
-    }
-}
-
-/// Decode an unsigned VINT (marker bit stripped). Returns `(value, length, all_ones)`.
-pub fn read_vint(data: &[u8]) -> Option<(u64, usize, bool)> {
-    let first = *data.first()?;
-    let len = vint_len(first)?;
-    if data.len() < len {
-        return None;
-    }
-    let mask = if len == 8 { 0 } else { 0xFFu8 >> len };
-    let mut v = (first & mask) as u64;
-    for &b in &data[1..len] {
-        v = (v << 8) | b as u64;
-    }
-    let all_ones = v == (1u64 << (7 * len)) - 1;
-    Some((v, len, all_ones))
-}
-
-/// Decode an element data size. All-ones is the reserved "unknown size".
-pub fn read_size(data: &[u8]) -> Option<(Size, usize)> {
-    let (v, len, ones) = read_vint(data)?;
-    Some((if ones { Size::Unknown } else { Size::Known(v) }, len))
-}
-
-/// Decode an element ID (marker bits kept, 1..=4 bytes). Rejects all-ones value bits (reserved).
-/// All-zero value bits are accepted, because Matroska's `ChapterDisplay` uses ID `0x80`.
-pub fn read_id(data: &[u8]) -> Option<(u32, usize)> {
-    let first = *data.first()?;
-    let len = vint_len(first)?;
-    if len > 4 || data.len() < len {
-        return None;
-    }
-    let (v, _, ones) = read_vint(&data[..len])?;
-    if ones || (v == 0 && len > 1) {
-        return None;
-    }
-    let mut id = 0u32;
-    for &b in &data[..len] {
-        id = (id << 8) | b as u32;
-    }
-    Some((id, len))
-}
-
-/// Decode a signed VINT as used by EBML lacing (value − (2^(7·len−1) − 1)).
-pub fn read_svint(data: &[u8]) -> Option<(i64, usize)> {
-    let (v, len, _) = read_vint(data)?;
-    let bias = (1i64 << (7 * len - 1)) - 1;
-    Some((v as i64 - bias, len))
-}
-
-/// Encode an element ID (already carrying its marker bits).
-pub fn write_id(out: &mut Vec<u8>, id: u32) {
-    let n = if id >= 0x100_0000 {
-        4
-    } else if id >= 0x1_0000 {
-        3
-    } else if id >= 0x100 {
-        2
-    } else {
-        1
-    };
-    out.extend_from_slice(&id.to_be_bytes()[4 - n..]);
-}
-
-/// Encode a data size as a VINT using the shortest length (or `min_len` if larger).
-pub fn write_size(out: &mut Vec<u8>, size: u64, min_len: usize) {
-    let mut len = 1;
-    while len < 8 && size >= (1u64 << (7 * len)) - 1 {
-        len += 1;
-    }
-    let len = len.max(min_len).min(8);
-    let v = size | (1u64 << (7 * len));
-    out.extend_from_slice(&v.to_be_bytes()[8 - len..]);
-}
-
-/// Encode the "unknown size" marker of the given length.
-pub fn write_unknown_size(out: &mut Vec<u8>, len: usize) {
-    out.push(0xFFu8 >> (len - 1));
-    out.extend(std::iter::repeat_n(0xFF, len - 1));
-}
-
-/// Big-endian unsigned integer of 0..=8 bytes.
-pub fn uint(data: &[u8]) -> u64 {
-    data.iter().take(8).fold(0u64, |a, &b| (a << 8) | b as u64)
-}
-
-/// Big-endian two's-complement signed integer of 0..=8 bytes.
-pub fn int(data: &[u8]) -> i64 {
-    let n = data.len().min(8);
-    if n == 0 {
-        return 0;
-    }
-    let v = uint(&data[..n]);
-    let shift = 64 - 8 * n as u32;
-    ((v << shift) as i64) >> shift
-}
-
-/// IEEE float of 0, 4 or 8 bytes.
-pub fn float(data: &[u8]) -> f64 {
-    match data.len() {
-        4 => f32::from_be_bytes(data.try_into().unwrap_or([0; 4])) as f64,
-        8 => f64::from_be_bytes(data.try_into().unwrap_or([0; 8])),
-        _ => 0.0,
-    }
-}
-
-/// String / UTF-8 value: bytes up to the first NUL, lossily decoded.
-pub fn string(data: &[u8]) -> String {
-    let end = data.iter().position(|&b| b == 0).unwrap_or(data.len());
-    String::from_utf8_lossy(&data[..end]).into_owned()
-}
-
-/// One element inside an in-memory master element.
-#[derive(Clone, Copy, Debug)]
-pub struct Elem<'a> {
-    pub id: u32,
-    /// Offset of the element header, relative to the start of the parent's data.
-    pub offset: usize,
-    pub header_len: usize,
-    pub data: &'a [u8],
-    /// The size field was "unknown" (data runs to the end of the parent).
-    pub unknown_size: bool,
-    /// The declared size overran the parent and was truncated.
-    pub truncated: bool,
-}
-
-/// Iterator over the children of an in-memory master element.
-///
-/// Damaged data ends the iteration (see [`Children::damaged`]); oversize elements are truncated to
-/// the parent's end.
-pub struct Children<'a> {
-    data: &'a [u8],
-    pos: usize,
-    damaged: bool,
-}
-
-impl<'a> Children<'a> {
-    pub fn new(data: &'a [u8]) -> Self {
-        Self { data, pos: 0, damaged: false }
-    }
-    /// True if iteration stopped on an undecodable header.
-    pub fn damaged(&self) -> bool {
-        self.damaged
-    }
-}
-
-impl<'a> Iterator for Children<'a> {
-    type Item = Elem<'a>;
-    fn next(&mut self) -> Option<Elem<'a>> {
-        let rest = self.data.get(self.pos..)?;
-        if rest.is_empty() {
-            return None;
-        }
-        let Some((id, il)) = read_id(rest) else {
-            self.damaged = true;
-            self.pos = self.data.len();
-            return None;
-        };
-        let Some((size, sl)) = read_size(&rest[il..]) else {
-            self.damaged = true;
-            self.pos = self.data.len();
-            return None;
-        };
-        let hl = il + sl;
-        let avail = (rest.len() - hl) as u64;
-        let (len, unknown, truncated) = match size {
-            Size::Known(n) if n <= avail => (n as usize, false, false),
-            Size::Known(_) => (avail as usize, false, true),
-            Size::Unknown => (avail as usize, true, false),
-        };
-        let e = Elem { id, offset: self.pos, header_len: hl, data: &rest[hl..hl + len], unknown_size: unknown, truncated };
-        self.pos += hl + len;
-        Some(e)
-    }
-}
-
-/// CRC-32 (ISO 3309 / IEEE 802.3, reflected polynomial 0xEDB88320), as used by EBML CRC-32 elements.
-pub fn crc32(data: &[u8]) -> u32 {
-    crc32_update(0xFFFF_FFFF, data) ^ 0xFFFF_FFFF
-}
-
-/// Incremental form: start with `0xFFFF_FFFF`, finish with `^ 0xFFFF_FFFF`.
-pub fn crc32_update(mut crc: u32, data: &[u8]) -> u32 {
-    static TABLE: std::sync::OnceLock<[u32; 256]> = std::sync::OnceLock::new();
-    let t = TABLE.get_or_init(|| {
-        let mut t = [0u32; 256];
-        for (i, e) in t.iter_mut().enumerate() {
-            let mut c = i as u32;
-            for _ in 0..8 {
-                c = if c & 1 != 0 { 0xEDB8_8320 ^ (c >> 1) } else { c >> 1 };
-            }
-            *e = c;
-        }
-        t
-    });
-    for &b in data {
-        crc = t[((crc ^ b as u32) & 0xFF) as usize] ^ (crc >> 8);
-    }
-    crc
-}
-
-/// Check a master element's leading CRC-32 child, if present. `Some(true/false)` if there is one.
-pub fn verify_crc(master_data: &[u8]) -> Option<bool> {
-    let mut it = Children::new(master_data);
-    let first = it.next()?;
-    if first.id != crate::ids::CRC32 || first.data.len() != 4 {
-        return None;
-    }
-    let stored = u32::from_le_bytes(first.data.try_into().ok()?);
-    let rest = &master_data[first.offset + first.header_len + 4..];
-    Some(crc32(rest) == stored)
-}
-
-/// Block lacing mode (flags bits 1–2).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Lacing {
-    None,
-    Xiph,
-    FixedSize,
-    Ebml,
-}
-
-impl Lacing {
-    pub fn from_flags(flags: u8) -> Lacing {
-        match (flags >> 1) & 3 {
-            0 => Lacing::None,
-            1 => Lacing::Xiph,
-            2 => Lacing::FixedSize,
-            _ => Lacing::Ebml,
-        }
-    }
-}
-
-/// Split laced block payload. `data` starts right after the block's flags byte and runs to the end
-/// of the block. Returns `(offset, len)` of each frame relative to `data`.
-pub fn parse_lacing(lacing: Lacing, data: &[u8]) -> Result<Vec<(usize, usize)>> {
-    if lacing == Lacing::None {
-        return Ok(vec![(0, data.len())]);
-    }
-    let Some(&n1) = data.first() else { return invalid("laced block without frame count") };
-    let count = n1 as usize + 1;
-    let mut pos = 1usize;
-    let mut sizes = Vec::with_capacity(count);
-    match lacing {
-        Lacing::None => return Ok(vec![(0, data.len())]),
-        Lacing::Xiph => {
-            for _ in 0..count - 1 {
-                let mut s = 0usize;
-                loop {
-                    let Some(&b) = data.get(pos) else { return invalid("truncated Xiph lace header") };
-                    pos += 1;
-                    s += b as usize;
-                    if b != 255 {
-                        break;
-                    }
-                }
-                sizes.push(s);
-            }
-        }
-        Lacing::Ebml => {
-            if count > 1 {
-                let Some((first, l, _)) = read_vint(&data[pos..]) else { return invalid("bad EBML lace size") };
-                pos += l;
-                let mut prev = first as i64;
-                sizes.push(first as usize);
-                for _ in 1..count - 1 {
-                    let Some((d, l)) = read_svint(&data[pos..]) else { return invalid("bad EBML lace delta") };
-                    pos += l;
-                    prev += d;
-                    if prev < 0 {
-                        return invalid("negative EBML lace size");
-                    }
-                    sizes.push(prev as usize);
-                }
-            }
-        }
-        Lacing::FixedSize => {
-            let rest = data.len() - pos;
-            if !rest.is_multiple_of(count) {
-                return invalid("fixed-size lacing does not divide block");
-            }
-            sizes.extend(std::iter::repeat_n(rest / count, count - 1));
-        }
-    }
-    let used: usize = sizes.iter().try_fold(0usize, |a, &s| a.checked_add(s)).unwrap_or(usize::MAX);
-    if pos > data.len() || used > data.len() - pos {
-        return invalid("lace sizes exceed block");
-    }
-    sizes.push(data.len() - pos - used);
-    let mut out = Vec::with_capacity(count);
-    for s in sizes {
-        out.push((pos, s));
-        pos += s;
-    }
-    Ok(out)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn vint_roundtrip() {
-        for &v in &[0u64, 1, 126, 127, 128, 16382, 16383, 16384, 1 << 20, (1 << 56) - 2] {
-            let mut b = Vec::new();
-            write_size(&mut b, v, 1);
-            let (s, l) = read_size(&b).unwrap();
-            assert_eq!(s, Size::Known(v), "value {v}");
-            assert_eq!(l, b.len());
-        }
-        // 127 needs 2 bytes because 0xFF is "unknown"
-        let mut b = Vec::new();
-        write_size(&mut b, 127, 1);
-        assert_eq!(b, [0x40, 0x7F]);
-        // padded length
-        let mut b = Vec::new();
-        write_size(&mut b, 5, 8);
-        assert_eq!(b, [1, 0, 0, 0, 0, 0, 0, 5]);
-        assert_eq!(read_size(&b).unwrap(), (Size::Known(5), 8));
-    }
-
-    #[test]
-    fn vint_unknown_and_invalid() {
-        assert_eq!(read_size(&[0xFF]).unwrap(), (Size::Unknown, 1));
-        assert_eq!(read_size(&[0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]).unwrap(), (Size::Unknown, 8));
-        for l in 1..=8 {
-            let mut b = Vec::new();
-            write_unknown_size(&mut b, l);
-            assert_eq!(read_size(&b).unwrap(), (Size::Unknown, l));
-        }
-        assert!(read_size(&[0x00, 1, 2]).is_none());
-        assert!(read_size(&[0x40]).is_none()); // truncated
-        assert_eq!(read_vint(&[0x81]).unwrap(), (1, 1, false));
-        assert_eq!(read_vint(&[0x10, 0x00, 0x00, 0x01]).unwrap(), (1, 4, false));
-    }
-
-    #[test]
-    fn ids() {
-        assert_eq!(read_id(&[0x1A, 0x45, 0xDF, 0xA3, 0x99]).unwrap(), (crate::ids::EBML, 4));
-        assert_eq!(read_id(&[0xA3]).unwrap(), (0xA3, 1));
-        assert_eq!(read_id(&[0x42, 0x86]).unwrap(), (0x4286, 2));
-        assert!(read_id(&[0xFF]).is_none()); // reserved
-        assert_eq!(read_id(&[0x80]).unwrap(), (0x80, 1)); // ChapterDisplay
-        assert!(read_id(&[0x40, 0x00]).is_none()); // zero value
-        assert!(read_id(&[0x08, 0, 0, 0, 1]).is_none()); // 5-byte ID
-        for id in [0xA3u32, 0x4286, 0x2AD7B1, 0x1F43B675] {
-            let mut b = Vec::new();
-            write_id(&mut b, id);
-            assert_eq!(read_id(&b).unwrap(), (id, b.len()));
-        }
-    }
-
-    #[test]
-    fn signed_vint() {
-        assert_eq!(read_svint(&[0xBF]).unwrap(), (0, 1)); // 63 - 63
-        assert_eq!(read_svint(&[0x80]).unwrap(), (-63, 1));
-        assert_eq!(read_svint(&[0xC0]).unwrap(), (1, 1));
-        assert_eq!(read_svint(&[0x5F, 0xFF]).unwrap(), (0, 2));
-        assert_eq!(read_svint(&[0x60, 0x00]).unwrap(), (1, 2));
-    }
-
-    #[test]
-    fn values() {
-        assert_eq!(uint(&[]), 0);
-        assert_eq!(uint(&[1, 0]), 256);
-        assert_eq!(int(&[0xFF]), -1);
-        assert_eq!(int(&[0xFF, 0xFE]), -2);
-        assert_eq!(int(&[0x7F]), 127);
-        assert_eq!(float(&1.5f32.to_be_bytes()), 1.5);
-        assert_eq!(float(&2.25f64.to_be_bytes()), 2.25);
-        assert_eq!(string(b"abc\0\0"), "abc");
-    }
-
-    #[test]
-    fn crc() {
-        assert_eq!(crc32(b"123456789"), 0xCBF4_3926);
-        let payload = [0x42u8, 0x86, 0x81, 0x01];
-        let mut m = vec![0xBF, 0x84];
-        m.extend_from_slice(&crc32(&payload).to_le_bytes());
-        m.extend_from_slice(&payload);
-        assert_eq!(verify_crc(&m), Some(true));
-        m[7] ^= 1;
-        assert_eq!(verify_crc(&m), Some(false));
-        assert_eq!(verify_crc(&payload), None);
-    }
-
-    #[test]
-    fn children_iter() {
-        // two elements, then one whose size overruns
-        let d = [0x42, 0x86, 0x81, 0x01, 0xEC, 0x82, 0, 0, 0xA3, 0x85, 1, 2];
-        let v: Vec<_> = Children::new(&d).collect();
-        assert_eq!(v.len(), 3);
-        assert_eq!(v[0].id, 0x4286);
-        assert_eq!(v[0].data, &[1]);
-        assert_eq!(v[1].id, 0xEC);
-        assert_eq!(v[2].data, &[1, 2]);
-        assert!(v[2].truncated);
-        let mut it = Children::new(&[0x00, 0x01]);
-        assert!(it.next().is_none());
-        assert!(it.damaged());
-    }
-
-    fn frames<'a>(d: &'a [u8], f: &[(usize, usize)]) -> Vec<&'a [u8]> {
-        f.iter().map(|&(o, l)| &d[o..o + l]).collect()
-    }
-
-    #[test]
-    fn lacing_xiph() {
-        // 3 frames: 300, 2, rest(3)
-        let mut d = vec![2u8, 255, 45, 2];
-        d.extend(std::iter::repeat_n(7u8, 300));
-        d.extend_from_slice(&[1, 2]);
-        d.extend_from_slice(&[3, 4, 5]);
-        let f = parse_lacing(Lacing::Xiph, &d).unwrap();
-        assert_eq!(f.iter().map(|x| x.1).collect::<Vec<_>>(), [300, 2, 3]);
-        assert_eq!(frames(&d, &f)[2], &[3, 4, 5]);
-        // exact multiple of 255 needs a terminating 0
-        let mut d = vec![1u8, 255, 0];
-        d.extend(std::iter::repeat_n(1u8, 255));
-        d.push(9);
-        let f = parse_lacing(Lacing::Xiph, &d).unwrap();
-        assert_eq!(f.iter().map(|x| x.1).collect::<Vec<_>>(), [255, 1]);
-        assert!(parse_lacing(Lacing::Xiph, &[1, 200, 1]).is_err());
-    }
-
-    #[test]
-    fn lacing_ebml() {
-        // 4 frames: 5, 3 (delta -2), 4 (delta +1), rest 2
-        let mut d = vec![3u8, 0x85, 0xBF - 2, 0xBF + 1];
-        d.extend_from_slice(&[1; 5]);
-        d.extend_from_slice(&[2; 3]);
-        d.extend_from_slice(&[3; 4]);
-        d.extend_from_slice(&[4; 2]);
-        let f = parse_lacing(Lacing::Ebml, &d).unwrap();
-        assert_eq!(f.iter().map(|x| x.1).collect::<Vec<_>>(), [5, 3, 4, 2]);
-        assert_eq!(frames(&d, &f), [&[1u8; 5][..], &[2; 3], &[3; 4], &[4; 2]]);
-        assert!(parse_lacing(Lacing::Ebml, &[1, 0x90]).is_err());
-    }
-
-    #[test]
-    fn lacing_fixed_and_none() {
-        let d = [2u8, 1, 1, 2, 2, 3, 3];
-        let f = parse_lacing(Lacing::FixedSize, &d).unwrap();
-        assert_eq!(frames(&d, &f), [&[1u8, 1][..], &[2, 2], &[3, 3]]);
-        assert!(parse_lacing(Lacing::FixedSize, &[2, 1, 1]).is_err());
-        assert_eq!(parse_lacing(Lacing::None, &[9, 9]).unwrap(), [(0, 2)]);
-        assert_eq!(Lacing::from_flags(0x80 | 0x06), Lacing::Ebml);
-        assert_eq!(Lacing::from_flags(0x02), Lacing::Xiph);
-        assert_eq!(Lacing::from_flags(0x04), Lacing::FixedSize);
-    }
-}
@@ -1,53 +0,0 @@
-use std::fmt;
-use std::io;
-
-/// Errors produced by the demuxer.
-#[derive(Debug)]
-pub enum Error {
-    /// Underlying I/O failure.
-    Io(io::Error),
-    /// Structurally invalid data that could not be recovered from.
-    Invalid(String),
-    /// Valid but unsupported feature (e.g. zlib-compressed or encrypted tracks when reading data).
-    Unsupported(String),
-    /// Not an EBML file, or an EBML file whose DocType is not `matroska`/`webm`.
-    NotMatroska(String),
-    /// A track index was out of range.
-    NoSuchTrack(usize),
-    /// A sample index was out of range.
-    NoSuchSample(usize),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Error::Io(e) => write!(f, "I/O error: {e}"),
-            Error::Invalid(s) => write!(f, "invalid data: {s}"),
-            Error::Unsupported(s) => write!(f, "unsupported: {s}"),
-            Error::NotMatroska(s) => write!(f, "not a Matroska/WebM file: {s}"),
-            Error::NoSuchTrack(i) => write!(f, "track index {i} out of range"),
-            Error::NoSuchSample(i) => write!(f, "sample index {i} out of range"),
-        }
-    }
-}
-
-impl std::error::Error for Error {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            Error::Io(e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Self {
-        Error::Io(e)
-    }
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-pub(crate) fn invalid<T>(msg: impl Into<String>) -> Result<T> {
-    Err(Error::Invalid(msg.into()))
-}
@@ -1,211 +0,0 @@
-//! EBML / Matroska element IDs (RFC 8794, RFC 9559). IDs keep their VINT marker bits.
-#![allow(dead_code)]
-
-// EBML header + global elements
-pub const EBML: u32 = 0x1A45_DFA3;
-pub const EBML_VERSION: u32 = 0x4286;
-pub const EBML_READ_VERSION: u32 = 0x42F7;
-pub const EBML_MAX_ID_LENGTH: u32 = 0x42F2;
-pub const EBML_MAX_SIZE_LENGTH: u32 = 0x42F3;
-pub const DOC_TYPE: u32 = 0x4282;
-pub const DOC_TYPE_VERSION: u32 = 0x4287;
-pub const DOC_TYPE_READ_VERSION: u32 = 0x4285;
-pub const CRC32: u32 = 0xBF;
-pub const VOID: u32 = 0xEC;
-
-// Segment and level-1 elements
-pub const SEGMENT: u32 = 0x1853_8067;
-pub const SEEK_HEAD: u32 = 0x114D_9B74;
-pub const INFO: u32 = 0x1549_A966;
-pub const TRACKS: u32 = 0x1654_AE6B;
-pub const CLUSTER: u32 = 0x1F43_B675;
-pub const CUES: u32 = 0x1C53_BB6B;
-pub const ATTACHMENTS: u32 = 0x1941_A469;
-pub const CHAPTERS: u32 = 0x1043_A770;
-pub const TAGS: u32 = 0x1254_C367;
-
-/// True for IDs that can only appear directly inside a Segment (or are the EBML/Segment headers):
-/// used to find the end of unknown-size elements.
-pub fn is_top_level(id: u32) -> bool {
-    matches!(id, EBML | SEGMENT | SEEK_HEAD | INFO | TRACKS | CLUSTER | CUES | ATTACHMENTS | CHAPTERS | TAGS)
-}
-
-// SeekHead
-pub const SEEK: u32 = 0x4DBB;
-pub const SEEK_ID: u32 = 0x53AB;
-pub const SEEK_POSITION: u32 = 0x53AC;
-
-// Info
-pub const SEGMENT_UUID: u32 = 0x73A4;
-pub const SEGMENT_FILENAME: u32 = 0x7384;
-pub const TIMESTAMP_SCALE: u32 = 0x2A_D7B1;
-pub const DURATION: u32 = 0x4489;
-pub const DATE_UTC: u32 = 0x4461;
-pub const TITLE: u32 = 0x7BA9;
-pub const MUXING_APP: u32 = 0x4D80;
-pub const WRITING_APP: u32 = 0x5741;
-
-// Cluster
-pub const TIMESTAMP: u32 = 0xE7;
-pub const POSITION: u32 = 0xA7;
-pub const PREV_SIZE: u32 = 0xAB;
-pub const SIMPLE_BLOCK: u32 = 0xA3;
-pub const BLOCK_GROUP: u32 = 0xA0;
-pub const ENCRYPTED_BLOCK: u32 = 0xAF;
-pub const SILENT_TRACKS: u32 = 0x5854;
-pub const BLOCK: u32 = 0xA1;
-pub const BLOCK_ADDITIONS: u32 = 0x75A1;
-pub const BLOCK_DURATION: u32 = 0x9B;
-pub const REFERENCE_PRIORITY: u32 = 0xFA;
-pub const REFERENCE_BLOCK: u32 = 0xFB;
-pub const CODEC_STATE: u32 = 0xA4;
-pub const DISCARD_PADDING: u32 = 0x75A2;
-
-pub fn is_cluster_child(id: u32) -> bool {
-    matches!(id, TIMESTAMP | POSITION | PREV_SIZE | SIMPLE_BLOCK | BLOCK_GROUP | ENCRYPTED_BLOCK | SILENT_TRACKS | CRC32 | VOID)
-}
-
-// Tracks
-pub const TRACK_ENTRY: u32 = 0xAE;
-pub const TRACK_NUMBER: u32 = 0xD7;
-pub const TRACK_UID: u32 = 0x73C5;
-pub const TRACK_TYPE: u32 = 0x83;
-pub const FLAG_ENABLED: u32 = 0xB9;
-pub const FLAG_DEFAULT: u32 = 0x88;
-pub const FLAG_FORCED: u32 = 0x55AA;
-pub const FLAG_HEARING_IMPAIRED: u32 = 0x55AB;
-pub const FLAG_VISUAL_IMPAIRED: u32 = 0x55AC;
-pub const FLAG_ORIGINAL: u32 = 0x55AE;
-pub const FLAG_COMMENTARY: u32 = 0x55AF;
-pub const FLAG_LACING: u32 = 0x9C;
-pub const DEFAULT_DURATION: u32 = 0x23_E383;
-pub const TRACK_TIMESTAMP_SCALE: u32 = 0x23_314F;
-pub const NAME: u32 = 0x536E;
-pub const LANGUAGE: u32 = 0x22_B59C;
-pub const LANGUAGE_BCP47: u32 = 0x22_B59D;
-pub const CODEC_ID: u32 = 0x86;
-pub const CODEC_PRIVATE: u32 = 0x63A2;
-pub const CODEC_NAME: u32 = 0x25_8688;
-pub const CODEC_DELAY: u32 = 0x56AA;
-pub const SEEK_PRE_ROLL: u32 = 0x56BB;
-
-// Video
-pub const VIDEO: u32 = 0xE0;
-pub const FLAG_INTERLACED: u32 = 0x9A;
-pub const FIELD_ORDER: u32 = 0x9D;
-pub const STEREO_MODE: u32 = 0x53B8;
-pub const ALPHA_MODE: u32 = 0x53C0;
-pub const PIXEL_WIDTH: u32 = 0xB0;
-pub const PIXEL_HEIGHT: u32 = 0xBA;
-pub const PIXEL_CROP_BOTTOM: u32 = 0x54AA;
-pub const PIXEL_CROP_TOP: u32 = 0x54BB;
-pub const PIXEL_CROP_LEFT: u32 = 0x54CC;
-pub const PIXEL_CROP_RIGHT: u32 = 0x54DD;
-pub const DISPLAY_WIDTH: u32 = 0x54B0;
-pub const DISPLAY_HEIGHT: u32 = 0x54BA;
-pub const DISPLAY_UNIT: u32 = 0x54B2;
-pub const COLOUR_SPACE: u32 = 0x2E_B524;
-pub const COLOUR: u32 = 0x55B0;
-pub const PROJECTION: u32 = 0x7670;
-pub const PROJECTION_TYPE: u32 = 0x7671;
-pub const PROJECTION_POSE_YAW: u32 = 0x7673;
-pub const PROJECTION_POSE_PITCH: u32 = 0x7674;
-pub const PROJECTION_POSE_ROLL: u32 = 0x7675;
-
-// Colour
-pub const MATRIX_COEFFICIENTS: u32 = 0x55B1;
-pub const BITS_PER_CHANNEL: u32 = 0x55B2;
-pub const CHROMA_SUBSAMPLING_HORZ: u32 = 0x55B3;
-pub const CHROMA_SUBSAMPLING_VERT: u32 = 0x55B4;
-pub const CB_SUBSAMPLING_HORZ: u32 = 0x55B5;
-pub const CB_SUBSAMPLING_VERT: u32 = 0x55B6;
-pub const CHROMA_SITING_HORZ: u32 = 0x55B7;
-pub const CHROMA_SITING_VERT: u32 = 0x55B8;
-pub const RANGE: u32 = 0x55B9;
-pub const TRANSFER_CHARACTERISTICS: u32 = 0x55BA;
-pub const PRIMARIES: u32 = 0x55BB;
-pub const MAX_CLL: u32 = 0x55BC;
-pub const MAX_FALL: u32 = 0x55BD;
-pub const MASTERING_METADATA: u32 = 0x55D0;
-pub const PRIMARY_R_X: u32 = 0x55D1;
-pub const PRIMARY_R_Y: u32 = 0x55D2;
-pub const PRIMARY_G_X: u32 = 0x55D3;
-pub const PRIMARY_G_Y: u32 = 0x55D4;
-pub const PRIMARY_B_X: u32 = 0x55D5;
-pub const PRIMARY_B_Y: u32 = 0x55D6;
-pub const WHITE_POINT_X: u32 = 0x55D7;
-pub const WHITE_POINT_Y: u32 = 0x55D8;
-pub const LUMINANCE_MAX: u32 = 0x55D9;
-pub const LUMINANCE_MIN: u32 = 0x55DA;
-
-// Audio
-pub const AUDIO: u32 = 0xE1;
-pub const SAMPLING_FREQUENCY: u32 = 0xB5;
-pub const OUTPUT_SAMPLING_FREQUENCY: u32 = 0x78B5;
-pub const CHANNELS: u32 = 0x9F;
-pub const BIT_DEPTH: u32 = 0x6264;
-
-// ContentEncodings
-pub const CONTENT_ENCODINGS: u32 = 0x6D80;
-pub const CONTENT_ENCODING: u32 = 0x6240;
-pub const CONTENT_ENCODING_ORDER: u32 = 0x5031;
-pub const CONTENT_ENCODING_SCOPE: u32 = 0x5032;
-pub const CONTENT_ENCODING_TYPE: u32 = 0x5033;
-pub const CONTENT_COMPRESSION: u32 = 0x5034;
-pub const CONTENT_COMP_ALGO: u32 = 0x4254;
-pub const CONTENT_COMP_SETTINGS: u32 = 0x4255;
-pub const CONTENT_ENCRYPTION: u32 = 0x5035;
-
-// Cues
-pub const CUE_POINT: u32 = 0xBB;
-pub const CUE_TIME: u32 = 0xB3;
-pub const CUE_TRACK_POSITIONS: u32 = 0xB7;
-pub const CUE_TRACK: u32 = 0xF7;
-pub const CUE_CLUSTER_POSITION: u32 = 0xF1;
-pub const CUE_RELATIVE_POSITION: u32 = 0xF0;
-pub const CUE_DURATION: u32 = 0xB2;
-pub const CUE_BLOCK_NUMBER: u32 = 0x5378;
-
-// Attachments
-pub const ATTACHED_FILE: u32 = 0x61A7;
-pub const FILE_DESCRIPTION: u32 = 0x467E;
-pub const FILE_NAME: u32 = 0x466E;
-pub const FILE_MEDIA_TYPE: u32 = 0x4660;
-pub const FILE_DATA: u32 = 0x465C;
-pub const FILE_UID: u32 = 0x46AE;
-
-// Chapters
-pub const EDITION_ENTRY: u32 = 0x45B9;
-pub const EDITION_UID: u32 = 0x45BC;
-pub const EDITION_FLAG_HIDDEN: u32 = 0x45BD;
-pub const EDITION_FLAG_DEFAULT: u32 = 0x45DB;
-pub const EDITION_FLAG_ORDERED: u32 = 0x45DD;
-pub const CHAPTER_ATOM: u32 = 0xB6;
-pub const CHAPTER_UID: u32 = 0x73C4;
-pub const CHAPTER_STRING_UID: u32 = 0x5654;
-pub const CHAPTER_TIME_START: u32 = 0x91;
-pub const CHAPTER_TIME_END: u32 = 0x92;
-pub const CHAPTER_FLAG_HIDDEN: u32 = 0x98;
-pub const CHAPTER_FLAG_ENABLED: u32 = 0x4598;
-pub const CHAPTER_DISPLAY: u32 = 0x80;
-pub const CHAP_STRING: u32 = 0x85;
-pub const CHAP_LANGUAGE: u32 = 0x437C;
-pub const CHAP_LANGUAGE_BCP47: u32 = 0x437D;
-pub const CHAP_COUNTRY: u32 = 0x437E;
-
-// Tags
-pub const TAG: u32 = 0x7373;
-pub const TARGETS: u32 = 0x63C0;
-pub const TARGET_TYPE_VALUE: u32 = 0x68CA;
-pub const TARGET_TYPE: u32 = 0x63CA;
-pub const TAG_TRACK_UID: u32 = 0x63C5;
-pub const TAG_EDITION_UID: u32 = 0x63C9;
-pub const TAG_CHAPTER_UID: u32 = 0x63C4;
-pub const TAG_ATTACHMENT_UID: u32 = 0x63C6;
-pub const SIMPLE_TAG: u32 = 0x67C8;
-pub const TAG_NAME: u32 = 0x45A3;
-pub const TAG_LANGUAGE: u32 = 0x447A;
-pub const TAG_LANGUAGE_BCP47: u32 = 0x447B;
-pub const TAG_DEFAULT: u32 = 0x4484;
-pub const TAG_STRING: u32 = 0x4487;
-pub const TAG_BINARY: u32 = 0x4485;
@@ -1,40 +1,6 @@
-//! Clean-room Matroska (MKV) and WebM demuxer, written from RFC 8794 (EBML), RFC 9559 (Matroska)
-//! and the WebM container guidelines.
-//!
-//! - [`open`] / [`open_with`] parse the EBML header and the first Segment (Info, Tracks, SeekHead,
-//!   Cues, Chapters, Tags, Attachments) and, by default, scan every Cluster's block headers to build
-//!   per-track [`Sample`] tables — the same shape as `deckcraft-isobmff`, so callers can treat both
-//!   containers alike. Frame data is read on demand with [`MkvFile::read_sample`].
-//! - [`Demuxer`] iterates [`Packet`]s in file order (from any [`ByteSource`], `Read + Seek`, or a
-//!   byte slice) and seeks to the keyframe preceding a time, via the index, Cues, or a cluster scan.
-//!
-//! Layer L0: no dependencies beyond `std`, no `unsafe`, builds for `wasm32-unknown-unknown`.
+//! Matroska (MKV) and WebM demuxer and muxer: a re-export of [`craft_media::matroska`] from
+//! craft-libs. Supported elements and limitations are in the craft-media README.

 #![cfg_attr(not(test), deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable))]

-mod codec;
-mod demux;
-pub mod ebml;
-mod error;
-mod ids;
-mod meta;
-mod mux;
-mod source;
-#[cfg(test)]
-mod synthetic_tests;
-mod track;
-
-pub use codec::Codec;
-pub use demux::{Demuxer, Keyframe, MkvFile, OpenOptions, Packet, SeekPoint, open, open_with};
-pub use error::{Error, Result};
-pub use meta::{
-    Attachment, Chapter, ChapterDisplay, ClusterInfo, CuePoint, CuePosition, Edition, SeekEntry, SegmentInfo, SimpleTag, Tag, TagTargets,
-};
-pub use mux::{LacingMode, MkvWriter, MuxOptions, TrackSpec};
-pub use source::{ByteSource, ReadSeekSource};
-pub use track::{AudioInfo, Colour, ContentEncoding, MasteringMetadata, Projection, Sample, Track, TrackKind, VideoInfo};
-
-/// Element IDs used by the demuxer (marker bits included), for callers inspecting raw elements.
-pub mod element_ids {
-    pub use crate::ids::*;
-}
+pub use craft_media::matroska::*;
@@ -1,612 +0,0 @@
-//! Segment-level metadata: Info, SeekHead, Cues, Chapters, Tags, Attachments — types and parsers
-//! for their in-memory element data.
-
-use crate::codec::map_codec;
-use crate::ebml::{Children, float, int, string, uint};
-use crate::ids::*;
-use crate::track::{AudioInfo, Colour, ContentEncoding, MasteringMetadata, Projection, Track, TrackKind, VideoInfo, gcd};
-
-/// `Info` element.
-#[derive(Clone, Debug, PartialEq)]
-pub struct SegmentInfo {
-    /// Nanoseconds per timestamp tick (default 1 000 000 = 1 ms).
-    pub timestamp_scale: u64,
-    /// `Duration` in timestamp ticks (float), if present.
-    pub duration: Option<f64>,
-    pub title: Option<String>,
-    pub muxing_app: String,
-    pub writing_app: String,
-    /// `DateUTC`: nanoseconds since 2001-01-01T00:00:00 UTC.
-    pub date_utc: Option<i64>,
-    pub segment_uuid: Option<[u8; 16]>,
-}
-
-impl Default for SegmentInfo {
-    fn default() -> Self {
-        Self {
-            timestamp_scale: 1_000_000,
-            duration: None,
-            title: None,
-            muxing_app: String::new(),
-            writing_app: String::new(),
-            date_utc: None,
-            segment_uuid: None,
-        }
-    }
-}
-
-/// One `SeekHead` entry: level-1 element ID and its position relative to the Segment data start.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SeekEntry {
-    pub id: u32,
-    pub position: u64,
-}
-
-/// One `CueTrackPositions` of a `CuePoint`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct CuePosition {
-    pub track: u64,
-    /// Cluster position relative to the Segment data start.
-    pub cluster_position: u64,
-    /// Block position relative to the Cluster data start.
-    pub relative_position: Option<u64>,
-    pub block_number: Option<u64>,
-    pub duration: Option<u64>,
-}
-
-/// One `CuePoint`.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CuePoint {
-    /// In timestamp ticks.
-    pub time: u64,
-    pub positions: Vec<CuePosition>,
-}
-
-/// A cluster found while scanning.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ClusterInfo {
-    /// Absolute offset of the Cluster element header.
-    pub offset: u64,
-    /// Absolute offset of the first child.
-    pub data_start: u64,
-    /// Absolute end offset (for unknown-size clusters, where the next top-level element starts).
-    pub end: u64,
-    /// Cluster `Timestamp` in ticks.
-    pub timestamp: u64,
-}
-
-/// One `ChapterDisplay`.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct ChapterDisplay {
-    pub string: String,
-    pub languages: Vec<String>,
-    pub languages_bcp47: Vec<String>,
-    pub countries: Vec<String>,
-}
-
-/// `ChapterAtom` (possibly nested).
-#[derive(Clone, Debug, PartialEq)]
-pub struct Chapter {
-    pub uid: u64,
-    pub string_uid: Option<String>,
-    pub start_ns: u64,
-    pub end_ns: Option<u64>,
-    pub hidden: bool,
-    pub enabled: bool,
-    pub displays: Vec<ChapterDisplay>,
-    pub children: Vec<Chapter>,
-}
-
-impl Chapter {
-    /// First display string, if any.
-    pub fn title(&self) -> Option<&str> {
-        self.displays.first().map(|d| d.string.as_str())
-    }
-}
-
-/// `EditionEntry`.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Edition {
-    pub uid: Option<u64>,
-    pub hidden: bool,
-    pub default: bool,
-    pub ordered: bool,
-    pub chapters: Vec<Chapter>,
-}
-
-/// `Targets` of a `Tag`. Empty UID lists mean "the whole segment".
-#[derive(Clone, Debug, PartialEq)]
-pub struct TagTargets {
-    pub type_value: u64,
-    pub type_name: Option<String>,
-    pub track_uids: Vec<u64>,
-    pub edition_uids: Vec<u64>,
-    pub chapter_uids: Vec<u64>,
-    pub attachment_uids: Vec<u64>,
-}
-
-impl Default for TagTargets {
-    fn default() -> Self {
-        Self {
-            type_value: 50,
-            type_name: None,
-            track_uids: Vec::new(),
-            edition_uids: Vec::new(),
-            chapter_uids: Vec::new(),
-            attachment_uids: Vec::new(),
-        }
-    }
-}
-
-/// `SimpleTag` (possibly nested).
-#[derive(Clone, Debug, PartialEq)]
-pub struct SimpleTag {
-    pub name: String,
-    pub language: String,
-    pub default: bool,
-    pub string: Option<String>,
-    pub binary: Option<Vec<u8>>,
-    pub children: Vec<SimpleTag>,
-}
-
-/// `Tag`.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Tag {
-    pub targets: TagTargets,
-    pub simple: Vec<SimpleTag>,
-}
-
-/// `AttachedFile` (listed only; the payload is located by `data_offset`/`data_size`).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Attachment {
-    pub uid: u64,
-    pub name: String,
-    pub media_type: String,
-    pub description: Option<String>,
-    pub data_offset: u64,
-    pub data_size: u64,
-}
-
-pub(crate) fn parse_info(d: &[u8]) -> SegmentInfo {
-    let mut info = SegmentInfo::default();
-    for e in Children::new(d) {
-        match e.id {
-            TIMESTAMP_SCALE => {
-                let v = uint(e.data);
-                if v > 0 {
-                    info.timestamp_scale = v;
-                }
-            }
-            DURATION => info.duration = Some(float(e.data)).filter(|v| v.is_finite() && *v >= 0.0),
-            TITLE => info.title = Some(string(e.data)),
-            MUXING_APP => info.muxing_app = string(e.data),
-            WRITING_APP => info.writing_app = string(e.data),
-            DATE_UTC => info.date_utc = Some(int(e.data)),
-            SEGMENT_UUID => info.segment_uuid = e.data.try_into().ok(),
-            _ => {}
-        }
-    }
-    info
-}
-
-pub(crate) fn parse_seekhead(d: &[u8]) -> Vec<SeekEntry> {
-    let mut out = Vec::new();
-    for s in Children::new(d).filter(|e| e.id == SEEK) {
-        let (mut id, mut pos) = (None, None);
-        for e in Children::new(s.data) {
-            match e.id {
-                SEEK_ID => id = Some(uint(e.data) as u32),
-                SEEK_POSITION => pos = Some(uint(e.data)),
-                _ => {}
-            }
-        }
-        if let (Some(id), Some(position)) = (id, pos) {
-            out.push(SeekEntry { id, position });
-        }
-    }
-    out
-}
-
-pub(crate) fn parse_cues(d: &[u8], out: &mut Vec<CuePoint>) {
-    for cp in Children::new(d).filter(|e| e.id == CUE_POINT) {
-        let mut time = None;
-        let mut positions = Vec::new();
-        for e in Children::new(cp.data) {
-            match e.id {
-                CUE_TIME => time = Some(uint(e.data)),
-                CUE_TRACK_POSITIONS => {
-                    let mut p = CuePosition { track: 0, cluster_position: u64::MAX, relative_position: None, block_number: None, duration: None };
-                    for c in Children::new(e.data) {
-                        match c.id {
-                            CUE_TRACK => p.track = uint(c.data),
-                            CUE_CLUSTER_POSITION => p.cluster_position = uint(c.data),
-                            CUE_RELATIVE_POSITION => p.relative_position = Some(uint(c.data)),
-                            CUE_BLOCK_NUMBER => p.block_number = Some(uint(c.data)),
-                            CUE_DURATION => p.duration = Some(uint(c.data)),
-                            _ => {}
-                        }
-                    }
-                    if p.track != 0 && p.cluster_position != u64::MAX {
-                        positions.push(p);
-                    }
-                }
-                _ => {}
-            }
-        }
-        if let Some(time) = time
-            && !positions.is_empty()
-        {
-            out.push(CuePoint { time, positions });
-        }
-    }
-}
-
-/// Deepest nesting of `ChapterAtom` / `SimpleTag` we follow. Deeper children are ignored so a hostile file cannot overflow the stack.
-const MAX_NESTING_DEPTH: usize = 32;
-
-fn parse_chapter(d: &[u8], depth: usize) -> Chapter {
-    let mut c =
-        Chapter { uid: 0, string_uid: None, start_ns: 0, end_ns: None, hidden: false, enabled: true, displays: Vec::new(), children: Vec::new() };
-    for e in Children::new(d) {
-        match e.id {
-            CHAPTER_UID => c.uid = uint(e.data),
-            CHAPTER_STRING_UID => c.string_uid = Some(string(e.data)),
-            CHAPTER_TIME_START => c.start_ns = uint(e.data),
-            CHAPTER_TIME_END => c.end_ns = Some(uint(e.data)),
-            CHAPTER_FLAG_HIDDEN => c.hidden = uint(e.data) != 0,
-            CHAPTER_FLAG_ENABLED => c.enabled = uint(e.data) != 0,
-            CHAPTER_DISPLAY => {
-                let mut disp = ChapterDisplay::default();
-                for x in Children::new(e.data) {
-                    match x.id {
-                        CHAP_STRING => disp.string = string(x.data),
-                        CHAP_LANGUAGE => disp.languages.push(string(x.data)),
-                        CHAP_LANGUAGE_BCP47 => disp.languages_bcp47.push(string(x.data)),
-                        CHAP_COUNTRY => disp.countries.push(string(x.data)),
-                        _ => {}
-                    }
-                }
-                if disp.languages.is_empty() {
-                    disp.languages.push("eng".into());
-                }
-                c.displays.push(disp);
-            }
-            CHAPTER_ATOM if depth + 1 < MAX_NESTING_DEPTH => c.children.push(parse_chapter(e.data, depth + 1)),
-            _ => {}
-        }
-    }
-    c
-}
-
-pub(crate) fn parse_chapters(d: &[u8], out: &mut Vec<Edition>) {
-    for ed in Children::new(d).filter(|e| e.id == EDITION_ENTRY) {
-        let mut edition = Edition::default();
-        for e in Children::new(ed.data) {
-            match e.id {
-                EDITION_UID => edition.uid = Some(uint(e.data)),
-                EDITION_FLAG_HIDDEN => edition.hidden = uint(e.data) != 0,
-                EDITION_FLAG_DEFAULT => edition.default = uint(e.data) != 0,
-                EDITION_FLAG_ORDERED => edition.ordered = uint(e.data) != 0,
-                CHAPTER_ATOM => edition.chapters.push(parse_chapter(e.data, 0)),
-                _ => {}
-            }
-        }
-        out.push(edition);
-    }
-}
-
-fn parse_simple_tag(d: &[u8], depth: usize) -> SimpleTag {
-    let mut t = SimpleTag { name: String::new(), language: "und".into(), default: true, string: None, binary: None, children: Vec::new() };
-    for e in Children::new(d) {
-        match e.id {
-            TAG_NAME => t.name = string(e.data),
-            TAG_LANGUAGE => t.language = string(e.data),
-            TAG_DEFAULT => t.default = uint(e.data) != 0,
-            TAG_STRING => t.string = Some(string(e.data)),
-            TAG_BINARY => t.binary = Some(e.data.to_vec()),
-            SIMPLE_TAG if depth + 1 < MAX_NESTING_DEPTH => t.children.push(parse_simple_tag(e.data, depth + 1)),
-            _ => {}
-        }
-    }
-    t
-}
-
-pub(crate) fn parse_tags(d: &[u8], out: &mut Vec<Tag>) {
-    for tg in Children::new(d).filter(|e| e.id == TAG) {
-        let mut tag = Tag::default();
-        for e in Children::new(tg.data) {
-            match e.id {
-                TARGETS => {
-                    for x in Children::new(e.data) {
-                        match x.id {
-                            TARGET_TYPE_VALUE => tag.targets.type_value = uint(x.data),
-                            TARGET_TYPE => tag.targets.type_name = Some(string(x.data)),
-                            TAG_TRACK_UID => tag.targets.track_uids.push(uint(x.data)),
-                            TAG_EDITION_UID => tag.targets.edition_uids.push(uint(x.data)),
-                            TAG_CHAPTER_UID => tag.targets.chapter_uids.push(uint(x.data)),
-                            TAG_ATTACHMENT_UID => tag.targets.attachment_uids.push(uint(x.data)),
-                            _ => {}
-                        }
-                    }
-                }
-                SIMPLE_TAG => tag.simple.push(parse_simple_tag(e.data, 0)),
-                _ => {}
-            }
-        }
-        out.push(tag);
-    }
-}
-
-fn parse_colour(d: &[u8]) -> Colour {
-    let mut c = Colour::default();
-    for e in Children::new(d) {
-        let v = || Some(uint(e.data));
-        match e.id {
-            MATRIX_COEFFICIENTS => c.matrix_coefficients = v(),
-            BITS_PER_CHANNEL => c.bits_per_channel = v(),
-            CHROMA_SUBSAMPLING_HORZ => c.chroma_subsampling_horz = v(),
-            CHROMA_SUBSAMPLING_VERT => c.chroma_subsampling_vert = v(),
-            CB_SUBSAMPLING_HORZ => c.cb_subsampling_horz = v(),
-            CB_SUBSAMPLING_VERT => c.cb_subsampling_vert = v(),
-            CHROMA_SITING_HORZ => c.chroma_siting_horz = v(),
-            CHROMA_SITING_VERT => c.chroma_siting_vert = v(),
-            RANGE => c.range = v(),
-            TRANSFER_CHARACTERISTICS => c.transfer_characteristics = v(),
-            PRIMARIES => c.primaries = v(),
-            MAX_CLL => c.max_cll = v(),
-            MAX_FALL => c.max_fall = v(),
-            MASTERING_METADATA => {
-                let mut m = MasteringMetadata::default();
-                for x in Children::new(e.data) {
-                    let f = float(x.data);
-                    match x.id {
-                        PRIMARY_R_X => m.primaries[0].0 = f,
-                        PRIMARY_R_Y => m.primaries[0].1 = f,
-                        PRIMARY_G_X => m.primaries[1].0 = f,
-                        PRIMARY_G_Y => m.primaries[1].1 = f,
-                        PRIMARY_B_X => m.primaries[2].0 = f,
-                        PRIMARY_B_Y => m.primaries[2].1 = f,
-                        WHITE_POINT_X => m.white_point.0 = f,
-                        WHITE_POINT_Y => m.white_point.1 = f,
-                        LUMINANCE_MAX => m.luminance_max = f,
-                        LUMINANCE_MIN => m.luminance_min = f,
-                        _ => {}
-                    }
-                }
-                c.mastering = Some(m);
-            }
-            _ => {}
-        }
-    }
-    c
-}
-
-fn parse_video(d: &[u8]) -> VideoInfo {
-    let mut v = VideoInfo::default();
-    for e in Children::new(d) {
-        let u = uint(e.data);
-        match e.id {
-            PIXEL_WIDTH => v.pixel_width = u as u32,
-            PIXEL_HEIGHT => v.pixel_height = u as u32,
-            DISPLAY_WIDTH => v.display_width = Some(u as u32),
-            DISPLAY_HEIGHT => v.display_height = Some(u as u32),
-            DISPLAY_UNIT => v.display_unit = u,
-            PIXEL_CROP_TOP => v.crop.0 = u as u32,
-            PIXEL_CROP_BOTTOM => v.crop.1 = u as u32,
-            PIXEL_CROP_LEFT => v.crop.2 = u as u32,
-            PIXEL_CROP_RIGHT => v.crop.3 = u as u32,
-            FLAG_INTERLACED => v.flag_interlaced = u,
-            FIELD_ORDER => v.field_order = Some(u),
-            STEREO_MODE => v.stereo_mode = Some(u),
-            ALPHA_MODE => v.alpha_mode = u,
-            COLOUR_SPACE => v.colour_space = e.data.try_into().ok(),
-            COLOUR => v.colour = Some(parse_colour(e.data)),
-            PROJECTION => {
-                let mut p = Projection::default();
-                for x in Children::new(e.data) {
-                    match x.id {
-                        PROJECTION_TYPE => p.projection_type = uint(x.data),
-                        PROJECTION_POSE_YAW => p.yaw = float(x.data),
-                        PROJECTION_POSE_PITCH => p.pitch = float(x.data),
-                        PROJECTION_POSE_ROLL => p.roll = float(x.data),
-                        _ => {}
-                    }
-                }
-                v.projection = Some(p);
-            }
-            _ => {}
-        }
-    }
-    v
-}
-
-fn parse_audio(d: &[u8]) -> AudioInfo {
-    let mut a = AudioInfo::default();
-    for e in Children::new(d) {
-        match e.id {
-            SAMPLING_FREQUENCY => a.sampling_frequency = float(e.data),
-            OUTPUT_SAMPLING_FREQUENCY => a.output_sampling_frequency = Some(float(e.data)),
-            CHANNELS => a.channels = uint(e.data),
-            BIT_DEPTH => a.bit_depth = Some(uint(e.data)),
-            _ => {}
-        }
-    }
-    a
-}
-
-fn parse_encodings(d: &[u8]) -> Vec<ContentEncoding> {
-    let mut list: Vec<(u64, ContentEncoding)> = Vec::new();
-    for ce in Children::new(d).filter(|e| e.id == CONTENT_ENCODING) {
-        let (mut order, mut scope, mut ty) = (0u64, 1u64, 0u64);
-        let mut comp: Option<(u64, Vec<u8>)> = None;
-        for e in Children::new(ce.data) {
-            match e.id {
-                CONTENT_ENCODING_ORDER => order = uint(e.data),
-                CONTENT_ENCODING_SCOPE => scope = uint(e.data),
-                CONTENT_ENCODING_TYPE => ty = uint(e.data),
-                CONTENT_COMPRESSION => {
-                    let (mut algo, mut settings) = (0u64, Vec::new());
-                    for x in Children::new(e.data) {
-                        match x.id {
-                            CONTENT_COMP_ALGO => algo = uint(x.data),
-                            CONTENT_COMP_SETTINGS => settings = x.data.to_vec(),
-                            _ => {}
-                        }
-                    }
-                    comp = Some((algo, settings));
-                }
-                _ => {}
-            }
-        }
-        let enc = if ty == 1 {
-            ContentEncoding::Encryption { scope }
-        } else {
-            let (algo, settings) = comp.unwrap_or((0, Vec::new()));
-            if algo == 3 {
-                ContentEncoding::HeaderStripping { bytes: settings, scope }
-            } else {
-                ContentEncoding::Compression { algo, settings, scope }
-            }
-        };
-        list.push((order, enc));
-    }
-    // highest order is applied last on muxing → first to undo; keep decode order
-    list.sort_by_key(|e| std::cmp::Reverse(e.0));
-    list.into_iter().map(|e| e.1).collect()
-}
-
-pub(crate) fn parse_tracks(d: &[u8], timestamp_scale: u64) -> Vec<Track> {
-    let g = gcd(timestamp_scale, 1_000_000_000);
-    let timebase = (timestamp_scale / g, 1_000_000_000 / g);
-    let mut out = Vec::new();
-    for te in Children::new(d).filter(|e| e.id == TRACK_ENTRY) {
-        let mut t = Track {
-            number: 0,
-            uid: 0,
-            kind: TrackKind::Other(0),
-            enabled: true,
-            default: true,
-            forced: false,
-            hearing_impaired: false,
-            lacing: true,
-            default_duration_ns: None,
-            name: String::new(),
-            language: "eng".into(),
-            language_bcp47: None,
-            codec_id: String::new(),
-            codec_private: Vec::new(),
-            codec_name: String::new(),
-            codec: crate::Codec::Other(String::new()),
-            codec_delay_ns: 0,
-            seek_pre_roll_ns: 0,
-            video: None,
-            audio: None,
-            encodings: Vec::new(),
-            timebase,
-            samples: Vec::new(),
-            sync: Vec::new(),
-        };
-        for e in Children::new(te.data) {
-            match e.id {
-                TRACK_NUMBER => t.number = uint(e.data),
-                TRACK_UID => t.uid = uint(e.data),
-                TRACK_TYPE => t.kind = TrackKind::from_type(uint(e.data)),
-                FLAG_ENABLED => t.enabled = uint(e.data) != 0,
-                FLAG_DEFAULT => t.default = uint(e.data) != 0,
-                FLAG_FORCED => t.forced = uint(e.data) != 0,
-                FLAG_HEARING_IMPAIRED => t.hearing_impaired = uint(e.data) != 0,
-                FLAG_LACING => t.lacing = uint(e.data) != 0,
-                DEFAULT_DURATION => t.default_duration_ns = Some(uint(e.data)).filter(|&v| v > 0),
-                NAME => t.name = string(e.data),
-                LANGUAGE => t.language = string(e.data),
-                LANGUAGE_BCP47 => t.language_bcp47 = Some(string(e.data)),
-                CODEC_ID => t.codec_id = string(e.data),
-                CODEC_PRIVATE => t.codec_private = e.data.to_vec(),
-                CODEC_NAME => t.codec_name = string(e.data),
-                CODEC_DELAY => t.codec_delay_ns = uint(e.data),
-                SEEK_PRE_ROLL => t.seek_pre_roll_ns = uint(e.data),
-                VIDEO => t.video = Some(parse_video(e.data)),
-                AUDIO => t.audio = Some(parse_audio(e.data)),
-                CONTENT_ENCODINGS => t.encodings = parse_encodings(e.data),
-                _ => {}
-            }
-        }
-        if t.number == 0 {
-            continue;
-        }
-        if t.kind == TrackKind::Audio && t.audio.is_none() {
-            t.audio = Some(AudioInfo::default());
-        }
-        // CodecPrivate may itself be header-stripped (scope bit 2 = private data)
-        for enc in &t.encodings {
-            if let ContentEncoding::HeaderStripping { bytes, scope } = enc
-                && scope & 2 != 0
-            {
-                let mut p = bytes.clone();
-                p.extend_from_slice(&t.codec_private);
-                t.codec_private = p;
-            }
-        }
-        t.codec = map_codec(&t.codec_id, &t.codec_private, t.audio.as_ref());
-        out.push(t);
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ebml::{write_id, write_size};
-
-    /// `levels` elements with id `id`, each holding the next; the innermost is empty.
-    fn nested(id: u32, levels: usize) -> Vec<u8> {
-        let mut inner = Vec::new();
-        for _ in 0..levels {
-            let mut e = Vec::new();
-            write_id(&mut e, id);
-            write_size(&mut e, inner.len() as u64, 1);
-            e.extend_from_slice(&inner);
-            inner = e;
-        }
-        inner
-    }
-
-    fn chapter_depth(c: &Chapter) -> usize {
-        1 + c.children.iter().map(chapter_depth).max().unwrap_or(0)
-    }
-
-    fn tag_depth(t: &SimpleTag) -> usize {
-        1 + t.children.iter().map(tag_depth).max().unwrap_or(0)
-    }
-
-    fn chapters_of(levels: usize) -> usize {
-        let mut edition = Vec::new();
-        write_id(&mut edition, EDITION_ENTRY);
-        let atoms = nested(CHAPTER_ATOM, levels);
-        write_size(&mut edition, atoms.len() as u64, 1);
-        edition.extend_from_slice(&atoms);
-        let mut out = Vec::new();
-        parse_chapters(&edition, &mut out);
-        chapter_depth(&out[0].chapters[0])
-    }
-
-    #[test]
-    fn chapter_nesting_is_bounded() {
-        assert_eq!(chapters_of(MAX_NESTING_DEPTH), MAX_NESTING_DEPTH);
-        assert_eq!(chapters_of(MAX_NESTING_DEPTH + 50), MAX_NESTING_DEPTH);
-    }
-
-    #[test]
-    fn simple_tag_nesting_is_bounded() {
-        for (levels, expected) in [(MAX_NESTING_DEPTH, MAX_NESTING_DEPTH), (MAX_NESTING_DEPTH + 50, MAX_NESTING_DEPTH)] {
-            let mut tag = Vec::new();
-            write_id(&mut tag, TAG);
-            let simple = nested(SIMPLE_TAG, levels);
-            write_size(&mut tag, simple.len() as u64, 1);
-            tag.extend_from_slice(&simple);
-            let mut out = Vec::new();
-            parse_tags(&tag, &mut out);
-            assert_eq!(tag_depth(&out[0].simple[0]), expected);
-        }
-    }
-}
@@ -1,539 +0,0 @@
-//! Minimal Matroska / WebM muxer: SimpleBlocks (optionally laced), BlockGroups for explicit
-//! durations, Cues, SeekHead, Info with Duration. Output must be `Write + Seek` (sizes and the
-//! SeekHead are back-patched on [`MkvWriter::finish`]).
-
-use std::io::{Seek, SeekFrom, Write};
-
-use crate::ebml::{write_id, write_size, write_unknown_size};
-use crate::error::{Error, Result};
-use crate::ids::*;
-use crate::track::TrackKind;
-
-/// Lacing used for audio tracks.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum LacingMode {
-    None,
-    Xiph,
-    Ebml,
-    /// Fixed-size lacing when consecutive frames have equal sizes, otherwise EBML lacing.
-    FixedOrEbml,
-}
-
-/// Track description for [`MkvWriter`].
-#[derive(Clone, Debug)]
-pub struct TrackSpec {
-    pub kind: TrackKind,
-    pub codec_id: String,
-    pub codec_private: Vec<u8>,
-    pub default_duration_ns: Option<u64>,
-    pub language: Option<String>,
-    pub name: Option<String>,
-    /// Pixel width/height for video tracks.
-    pub video_size: Option<(u32, u32)>,
-    /// (sampling frequency, channels, bit depth) for audio tracks.
-    pub audio: Option<(f64, u64, Option<u64>)>,
-    pub codec_delay_ns: u64,
-    pub seek_pre_roll_ns: u64,
-}
-
-impl TrackSpec {
-    pub fn new(kind: TrackKind, codec_id: impl Into<String>) -> Self {
-        Self {
-            kind,
-            codec_id: codec_id.into(),
-            codec_private: Vec::new(),
-            default_duration_ns: None,
-            language: None,
-            name: None,
-            video_size: None,
-            audio: None,
-            codec_delay_ns: 0,
-            seek_pre_roll_ns: 0,
-        }
-    }
-}
-
-/// Muxer options.
-#[derive(Clone, Debug)]
-pub struct MuxOptions {
-    /// `webm` or `matroska`.
-    pub doc_type: String,
-    /// Nanoseconds per tick (default 1 000 000).
-    pub timestamp_scale: u64,
-    /// Start a new cluster at the next video keyframe (or any frame without video) after this long.
-    pub cluster_duration_ns: u64,
-    pub lacing: LacingMode,
-    /// Maximum frames per laced block.
-    pub max_lace_frames: usize,
-    pub title: Option<String>,
-    pub writing_app: String,
-}
-
-impl Default for MuxOptions {
-    fn default() -> Self {
-        Self {
-            doc_type: "matroska".into(),
-            timestamp_scale: 1_000_000,
-            cluster_duration_ns: 1_000_000_000,
-            lacing: LacingMode::None,
-            max_lace_frames: 8,
-            title: None,
-            writing_app: "deckcraft".into(),
-        }
-    }
-}
-
-pub(crate) fn el(out: &mut Vec<u8>, id: u32, data: &[u8]) {
-    write_id(out, id);
-    write_size(out, data.len() as u64, 1);
-    out.extend_from_slice(data);
-}
-
-pub(crate) fn el_uint(out: &mut Vec<u8>, id: u32, v: u64) {
-    let n = (8 - v.leading_zeros() as usize / 8).max(1);
-    el(out, id, &v.to_be_bytes()[8 - n..]);
-}
-
-pub(crate) fn el_float(out: &mut Vec<u8>, id: u32, v: f64) {
-    el(out, id, &v.to_be_bytes());
-}
-
-pub(crate) fn el_str(out: &mut Vec<u8>, id: u32, s: &str) {
-    el(out, id, s.as_bytes());
-}
-
-fn void(out: &mut Vec<u8>, total: usize) {
-    debug_assert!(total >= 2);
-    let sl = if total - 2 <= 126 { 1 } else { 8 };
-    write_id(out, VOID);
-    write_size(out, (total - 1 - sl) as u64, sl);
-    out.resize(out.len() + total - 1 - sl, 0);
-}
-
-#[derive(Clone, Debug)]
-struct Pending {
-    track: usize,
-    ts: i64,
-    frames: Vec<Vec<u8>>,
-}
-
-const SEEK_HEAD_SPACE: usize = 128;
-
-/// Streaming Matroska/WebM writer.
-pub struct MkvWriter<W: Write + Seek> {
-    w: W,
-    opts: MuxOptions,
-    tracks: Vec<TrackSpec>,
-    segment_size_pos: u64,
-    segment_data_start: u64,
-    seek_head_pos: u64,
-    duration_pos: u64,
-    info_pos: u64,
-    tracks_pos: u64,
-    cluster: Vec<u8>,
-    cluster_ts: Option<i64>,
-    cluster_start_ns: i64,
-    pending: Option<Pending>,
-    cues: Vec<(u64, u64, u64)>, // (time ticks, track number, cluster position)
-    cued_tracks_in_cluster: Vec<bool>,
-    end_ns: i64,
-    has_video: bool,
-}
-
-impl<W: Write + Seek> MkvWriter<W> {
-    pub fn new(mut w: W, tracks: Vec<TrackSpec>, opts: MuxOptions) -> Result<Self> {
-        if tracks.is_empty() || opts.timestamp_scale == 0 {
-            return Err(Error::Invalid("muxer needs at least one track and a non-zero timestamp scale".into()));
-        }
-        let mut out = Vec::new();
-        let mut h = Vec::new();
-        el_uint(&mut h, EBML_VERSION, 1);
-        el_uint(&mut h, EBML_READ_VERSION, 1);
-        el_uint(&mut h, EBML_MAX_ID_LENGTH, 4);
-        el_uint(&mut h, EBML_MAX_SIZE_LENGTH, 8);
-        el_str(&mut h, DOC_TYPE, &opts.doc_type);
-        el_uint(&mut h, DOC_TYPE_VERSION, 4);
-        el_uint(&mut h, DOC_TYPE_READ_VERSION, 2);
-        el(&mut out, EBML, &h);
-        write_id(&mut out, SEGMENT);
-        let base = w.stream_position()?;
-        let segment_size_pos = base + out.len() as u64;
-        write_unknown_size(&mut out, 8);
-        let segment_data_start = base + out.len() as u64;
-        let seek_head_pos = segment_data_start;
-        void(&mut out, SEEK_HEAD_SPACE);
-        // Info
-        let info_pos = base + out.len() as u64;
-        let mut info = Vec::new();
-        el_uint(&mut info, TIMESTAMP_SCALE, opts.timestamp_scale);
-        el_str(&mut info, MUXING_APP, "deckcraft-matroska");
-        el_str(&mut info, WRITING_APP, &opts.writing_app);
-        if let Some(t) = &opts.title {
-            el_str(&mut info, TITLE, t);
-        }
-        let dur_off_in_info = info.len() + 2 + 1; // ID (2) + size (1)
-        el_float(&mut info, DURATION, 0.0);
-        write_id(&mut out, INFO);
-        write_size(&mut out, info.len() as u64, 1);
-        let duration_pos = base + out.len() as u64 + dur_off_in_info as u64;
-        out.extend_from_slice(&info);
-        // Tracks
-        let tracks_pos = base + out.len() as u64;
-        let mut tr = Vec::new();
-        for (i, t) in tracks.iter().enumerate() {
-            let mut e = Vec::new();
-            el_uint(&mut e, TRACK_NUMBER, i as u64 + 1);
-            el_uint(&mut e, TRACK_UID, 0x1000 + i as u64 + 1);
-            let ty = match t.kind {
-                TrackKind::Video => 1,
-                TrackKind::Audio => 2,
-                TrackKind::Subtitle => 0x11,
-                TrackKind::Complex => 3,
-                TrackKind::Logo => 0x10,
-                TrackKind::Buttons => 0x12,
-                TrackKind::Control => 0x20,
-                TrackKind::Metadata => 0x21,
-                TrackKind::Other(n) => n as u64,
-            };
-            el_uint(&mut e, TRACK_TYPE, ty);
-            el_uint(&mut e, FLAG_LACING, (t.kind == TrackKind::Audio && opts.lacing != LacingMode::None) as u64);
-            if let Some(l) = &t.language {
-                el_str(&mut e, LANGUAGE, l);
-            }
-            if let Some(n) = &t.name {
-                el_str(&mut e, NAME, n);
-            }
-            el_str(&mut e, CODEC_ID, &t.codec_id);
-            if !t.codec_private.is_empty() {
-                el(&mut e, CODEC_PRIVATE, &t.codec_private);
-            }
-            if let Some(d) = t.default_duration_ns {
-                el_uint(&mut e, DEFAULT_DURATION, d);
-            }
-            if t.codec_delay_ns > 0 {
-                el_uint(&mut e, CODEC_DELAY, t.codec_delay_ns);
-            }
-            if t.seek_pre_roll_ns > 0 {
-                el_uint(&mut e, SEEK_PRE_ROLL, t.seek_pre_roll_ns);
-            }
-            if let Some((pw, ph)) = t.video_size {
-                let mut v = Vec::new();
-                el_uint(&mut v, PIXEL_WIDTH, pw as u64);
-                el_uint(&mut v, PIXEL_HEIGHT, ph as u64);
-                el(&mut e, VIDEO, &v);
-            }
-            if let Some((rate, ch, bits)) = t.audio {
-                let mut a = Vec::new();
-                el_float(&mut a, SAMPLING_FREQUENCY, rate);
-                el_uint(&mut a, CHANNELS, ch);
-                if let Some(b) = bits {
-                    el_uint(&mut a, BIT_DEPTH, b);
-                }
-                el(&mut e, AUDIO, &a);
-            }
-            el(&mut tr, TRACK_ENTRY, &e);
-        }
-        el(&mut out, TRACKS, &tr);
-        w.write_all(&out)?;
-        let has_video = tracks.iter().any(|t| t.kind == TrackKind::Video);
-        let n = tracks.len();
-        Ok(Self {
-            w,
-            opts,
-            tracks,
-            segment_size_pos,
-            segment_data_start,
-            seek_head_pos,
-            duration_pos,
-            info_pos,
-            tracks_pos,
-            cluster: Vec::new(),
-            cluster_ts: None,
-            cluster_start_ns: 0,
-            pending: None,
-            cues: Vec::new(),
-            cued_tracks_in_cluster: vec![false; n],
-            end_ns: 0,
-            has_video,
-        })
-    }
-
-    /// Add one frame. `pts_ns` is the presentation time (codec delay is added back for storage);
-    /// frames must be supplied in the desired file order. `duration_ns` forces a BlockGroup with a
-    /// BlockDuration when it differs from the track's DefaultDuration.
-    pub fn write_frame(&mut self, track: usize, pts_ns: i64, keyframe: bool, data: &[u8], duration_ns: Option<u64>) -> Result<()> {
-        let spec = self.tracks.get(track).ok_or(Error::NoSuchTrack(track))?;
-        // the Matroska ProRes mapping stores frames without the 8-byte `size`+`icpf` header
-        let data = if spec.codec_id == "V_PRORES" && data.get(4..8) == Some(b"icpf") { &data[8..] } else { data };
-        let scale = self.opts.timestamp_scale as i64;
-        let stored_ns = pts_ns + spec.codec_delay_ns as i64;
-        if stored_ns < 0 {
-            return Err(Error::Invalid("negative timestamp".into()));
-        }
-        let ts = (stored_ns + scale / 2) / scale;
-        let dur_end = pts_ns + duration_ns.or(spec.default_duration_ns).unwrap_or(0) as i64;
-        self.end_ns = self.end_ns.max(dur_end).max(pts_ns);
-        let is_video = spec.kind == TrackKind::Video;
-        let lacing = spec.kind == TrackKind::Audio && self.opts.lacing != LacingMode::None;
-        let explicit_dur = duration_ns.filter(|&d| Some(d) != spec.default_duration_ns);
-        // new cluster?
-        let start_new = match self.cluster_ts {
-            None => true,
-            Some(cts) => {
-                let long = stored_ns - self.cluster_start_ns >= self.opts.cluster_duration_ns as i64;
-                (long && (!self.has_video || (is_video && keyframe))) || ts - cts > 30_000 || ts < cts
-            }
-        };
-        if start_new {
-            self.flush_cluster()?;
-            self.cluster_ts = Some(ts);
-            self.cluster_start_ns = stored_ns;
-            el_uint(&mut self.cluster, TIMESTAMP, ts as u64);
-        }
-        let cts = self.cluster_ts.unwrap_or(0);
-        // cue: video keyframes, or the first frame of each track per cluster when there is no video
-        if (is_video && keyframe) || (!self.has_video && !self.cued_tracks_in_cluster[track]) {
-            self.cued_tracks_in_cluster[track] = true;
-            let pos = self.w.stream_position()? - self.segment_data_start;
-            if self.cues.last().is_none_or(|c| c.2 != pos || c.1 != track as u64 + 1) {
-                self.cues.push((ts as u64, track as u64 + 1, pos));
-            }
-        }
-        if lacing && explicit_dur.is_none() {
-            let same = self.pending.as_ref().is_some_and(|p| p.track == track && p.frames.len() < self.opts.max_lace_frames);
-            if !same {
-                self.flush_pending();
-            }
-            match &mut self.pending {
-                Some(p) => p.frames.push(data.to_vec()),
-                None => self.pending = Some(Pending { track, ts: ts - cts, frames: vec![data.to_vec()] }),
-            }
-            return Ok(());
-        }
-        self.flush_pending();
-        let mut block = Vec::new();
-        write_size(&mut block, track as u64 + 1, 1);
-        block.extend_from_slice(&((ts - cts) as i16).to_be_bytes());
-        if let Some(d) = explicit_dur {
-            block.push(0);
-            block.extend_from_slice(data);
-            let mut g = Vec::new();
-            el(&mut g, BLOCK, &block);
-            el_uint(&mut g, BLOCK_DURATION, (d as i64 / scale) as u64);
-            if !keyframe {
-                el(&mut g, REFERENCE_BLOCK, &[0xFF]);
-            }
-            el(&mut self.cluster, BLOCK_GROUP, &g);
-        } else {
-            block.push(if keyframe { 0x80 } else { 0 });
-            block.extend_from_slice(data);
-            el(&mut self.cluster, SIMPLE_BLOCK, &block);
-        }
-        Ok(())
-    }
-
-    fn flush_pending(&mut self) {
-        let Some(p) = self.pending.take() else { return };
-        let mut block = Vec::new();
-        write_size(&mut block, p.track as u64 + 1, 1);
-        block.extend_from_slice(&(p.ts as i16).to_be_bytes());
-        let n = p.frames.len();
-        let mode = if n == 1 { LacingMode::None } else { self.opts.lacing };
-        let fixed = p.frames.iter().all(|f| f.len() == p.frames[0].len());
-        match mode {
-            LacingMode::None => block.push(0x80),
-            LacingMode::Xiph => {
-                block.push(0x80 | 0x02);
-                block.push((n - 1) as u8);
-                for f in &p.frames[..n - 1] {
-                    let mut s = f.len();
-                    while s >= 255 {
-                        block.push(255);
-                        s -= 255;
-                    }
-                    block.push(s as u8);
-                }
-            }
-            LacingMode::FixedOrEbml if fixed => {
-                block.push(0x80 | 0x04);
-                block.push((n - 1) as u8);
-            }
-            LacingMode::Ebml | LacingMode::FixedOrEbml => {
-                block.push(0x80 | 0x06);
-                block.push((n - 1) as u8);
-                write_size(&mut block, p.frames[0].len() as u64, 1);
-                for i in 1..n - 1 {
-                    let d = p.frames[i].len() as i64 - p.frames[i - 1].len() as i64;
-                    // signed VINT: smallest length whose range holds d
-                    let mut len = 1;
-                    while len < 8 && d.unsigned_abs() >= (1u64 << (7 * len - 1)) - 1 {
-                        len += 1;
-                    }
-                    let v = (d + (1i64 << (7 * len - 1)) - 1) as u64 | (1u64 << (7 * len));
-                    block.extend_from_slice(&v.to_be_bytes()[8 - len..]);
-                }
-            }
-        }
-        for f in &p.frames {
-            block.extend_from_slice(f);
-        }
-        el(&mut self.cluster, SIMPLE_BLOCK, &block);
-    }
-
-    fn flush_cluster(&mut self) -> Result<()> {
-        self.flush_pending();
-        if self.cluster_ts.is_some() {
-            let mut out = Vec::new();
-            el(&mut out, CLUSTER, &self.cluster);
-            self.w.write_all(&out)?;
-        }
-        self.cluster.clear();
-        self.cluster_ts = None;
-        self.cued_tracks_in_cluster.iter_mut().for_each(|c| *c = false);
-        Ok(())
-    }
-
-    /// Write Cues, back-patch SeekHead / Segment size / Duration, and return the writer.
-    pub fn finish(mut self) -> Result<W> {
-        self.flush_cluster()?;
-        let cues_pos = self.w.stream_position()?;
-        let mut cues = Vec::new();
-        for &(time, track, pos) in &self.cues {
-            let mut ctp = Vec::new();
-            el_uint(&mut ctp, CUE_TRACK, track);
-            el_uint(&mut ctp, CUE_CLUSTER_POSITION, pos);
-            let mut cp = Vec::new();
-            el_uint(&mut cp, CUE_TIME, time);
-            el(&mut cp, CUE_TRACK_POSITIONS, &ctp);
-            el(&mut cues, CUE_POINT, &cp);
-        }
-        let has_cues = !cues.is_empty();
-        if has_cues {
-            let mut out = Vec::new();
-            el(&mut out, CUES, &cues);
-            self.w.write_all(&out)?;
-        }
-        let end = self.w.stream_position()?;
-        // SeekHead
-        let mut sh = Vec::new();
-        let mut entries = vec![(INFO, self.info_pos), (TRACKS, self.tracks_pos)];
-        if has_cues {
-            entries.push((CUES, cues_pos));
-        }
-        for (id, pos) in entries {
-            let mut s = Vec::new();
-            let mut idb = Vec::new();
-            write_id(&mut idb, id);
-            el(&mut s, SEEK_ID, &idb);
-            el_uint(&mut s, SEEK_POSITION, pos - self.segment_data_start);
-            el(&mut sh, SEEK, &s);
-        }
-        let mut out = Vec::new();
-        el(&mut out, SEEK_HEAD, &sh);
-        if out.len() + 2 > SEEK_HEAD_SPACE {
-            return Err(Error::Invalid("SeekHead does not fit its reserved space".into()));
-        }
-        let rest = SEEK_HEAD_SPACE - out.len();
-        void(&mut out, rest);
-        self.w.seek(SeekFrom::Start(self.seek_head_pos))?;
-        self.w.write_all(&out)?;
-        // Duration
-        let dur = self.end_ns as f64 / self.opts.timestamp_scale as f64;
-        self.w.seek(SeekFrom::Start(self.duration_pos))?;
-        self.w.write_all(&dur.to_be_bytes())?;
-        // Segment size
-        let mut sz = Vec::new();
-        write_size(&mut sz, end - self.segment_data_start, 8);
-        self.w.seek(SeekFrom::Start(self.segment_size_pos))?;
-        self.w.write_all(&sz)?;
-        self.w.seek(SeekFrom::Start(end))?;
-        self.w.flush()?;
-        Ok(self.w)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Demuxer, TrackKind};
-    use std::io::Cursor;
-
-    fn roundtrip(lacing: LacingMode) {
-        let mut v = TrackSpec::new(TrackKind::Video, "V_MJPEG");
-        v.video_size = Some((16, 16));
-        v.default_duration_ns = Some(40_000_000);
-        let mut a = TrackSpec::new(TrackKind::Audio, "A_PCM/INT/LIT");
-        a.audio = Some((48000.0, 1, Some(16)));
-        a.default_duration_ns = Some(10_000_000);
-        let mut s = TrackSpec::new(TrackKind::Subtitle, "S_TEXT/UTF8");
-        s.language = Some("fre".into());
-        let opts = MuxOptions { lacing, ..Default::default() };
-        let mut m = MkvWriter::new(Cursor::new(Vec::new()), vec![v, a, s], opts).unwrap();
-        let mut expect = Vec::new();
-        for i in 0..50i64 {
-            let vf = vec![i as u8; 100 + i as usize];
-            m.write_frame(0, i * 40_000_000, i % 10 == 0, &vf, None).unwrap();
-            expect.push((0usize, i * 40, vf, i % 10 == 0));
-            for k in 0..4 {
-                let n = if lacing == LacingMode::FixedOrEbml { 960 } else { 900 + (i as usize * 7 + k * 13) % 300 };
-                let af = vec![(i * 4 + k as i64) as u8; n];
-                let t = i * 40 + k as i64 * 10;
-                m.write_frame(1, t * 1_000_000, true, &af, None).unwrap();
-                expect.push((1, t, af, true));
-            }
-            if i % 20 == 5 {
-                m.write_frame(2, i * 40_000_000, true, b"hello", Some(500_000_000)).unwrap();
-                expect.push((2, i * 40, b"hello".to_vec(), true));
-            }
-        }
-        let bytes = m.finish().unwrap().into_inner();
-        let mut d = Demuxer::from_slice(&bytes).unwrap();
-        assert!(d.file().warnings.is_empty(), "{:?}", d.file().warnings);
-        assert_eq!(d.tracks()[2].language, "fre");
-        assert!(!d.file().cues.is_empty());
-        assert_eq!(d.duration_ns(), Some(2_300_000_000));
-        let got: Vec<_> = d.by_ref().map(|p| p.unwrap()).collect();
-        assert_eq!(got.len(), expect.len());
-        for (g, e) in got.iter().zip(&expect) {
-            assert_eq!((g.track, g.pts, &g.data, g.keyframe), (e.0, e.1, &e.2, e.3));
-        }
-        let sub = got.iter().find(|p| p.track == 2).unwrap();
-        assert_eq!(sub.duration, 500);
-        // the index agrees with the packet stream
-        let f = d.file();
-        for (ti, t) in f.tracks.iter().enumerate() {
-            let pk: Vec<_> = got.iter().filter(|p| p.track == ti).collect();
-            assert_eq!(t.samples.len(), pk.len());
-            for (i, p) in pk.iter().enumerate() {
-                assert_eq!(f.read_sample(&bytes[..], ti, i).unwrap(), p.data);
-                assert_eq!(t.samples[i].pts, p.pts);
-            }
-        }
-        // seeking
-        let sp = d.seek(0, 1_230_000_000).unwrap();
-        assert_eq!(sp.pts, 1200);
-        let p = d.next_packet().unwrap().unwrap();
-        assert_eq!((p.track, p.pts, p.keyframe), (0, 1200, true));
-        let sp = d.seek(1, 1_235_000_000).unwrap();
-        assert_eq!(sp.pts, 1230);
-        let p = d.next_packet().unwrap().unwrap();
-        assert_eq!((p.track, p.pts), (1, 1230));
-    }
-
-    #[test]
-    fn roundtrip_unlaced() {
-        roundtrip(LacingMode::None);
-    }
-    #[test]
-    fn roundtrip_xiph() {
-        roundtrip(LacingMode::Xiph);
-    }
-    #[test]
-    fn roundtrip_ebml() {
-        roundtrip(LacingMode::Ebml);
-    }
-    #[test]
-    fn roundtrip_fixed() {
-        roundtrip(LacingMode::FixedOrEbml);
-    }
-}
@@ -1,173 +0,0 @@
-//! Random-access byte sources for the demuxer.
-
-use std::cell::RefCell;
-use std::io::{self, Read, Seek, SeekFrom};
-use std::sync::Arc;
-
-/// Random-access, read-only byte source (file, in-memory buffer, web Blob…).
-///
-/// Same shape as `deckcraft_isobmff::ByteSource`, so one adapter can serve both demuxers.
-pub trait ByteSource {
-    /// Total length in bytes.
-    fn len(&self) -> u64;
-    /// Fill `buf` entirely with bytes starting at `offset`; fail with `UnexpectedEof` if past the end.
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()>;
-    /// True if the source holds no bytes.
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-}
-
-fn eof() -> io::Error {
-    io::Error::new(io::ErrorKind::UnexpectedEof, "read past end of byte source")
-}
-
-impl ByteSource for [u8] {
-    fn len(&self) -> u64 {
-        <[u8]>::len(self) as u64
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        let start = usize::try_from(offset).map_err(|_| eof())?;
-        let end = start.checked_add(buf.len()).ok_or_else(eof)?;
-        let src = self.get(start..end).ok_or_else(eof)?;
-        buf.copy_from_slice(src);
-        Ok(())
-    }
-}
-
-impl ByteSource for Vec<u8> {
-    fn len(&self) -> u64 {
-        self.as_slice().len() as u64
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        self.as_slice().read_at(offset, buf)
-    }
-}
-
-impl<T: ByteSource + ?Sized> ByteSource for &T {
-    fn len(&self) -> u64 {
-        (**self).len()
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_at(offset, buf)
-    }
-}
-
-impl<T: ByteSource + ?Sized> ByteSource for Arc<T> {
-    fn len(&self) -> u64 {
-        (**self).len()
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_at(offset, buf)
-    }
-}
-
-impl<T: ByteSource + ?Sized> ByteSource for Box<T> {
-    fn len(&self) -> u64 {
-        (**self).len()
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        (**self).read_at(offset, buf)
-    }
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-impl ByteSource for std::fs::File {
-    fn len(&self) -> u64 {
-        self.metadata().map(|m| m.len()).unwrap_or(0)
-    }
-    #[cfg(unix)]
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        std::os::unix::fs::FileExt::read_exact_at(self, buf, offset)
-    }
-    #[cfg(windows)]
-    fn read_at(&self, mut offset: u64, mut buf: &mut [u8]) -> io::Result<()> {
-        use std::os::windows::fs::FileExt;
-        while !buf.is_empty() {
-            let n = self.seek_read(buf, offset)?;
-            if n == 0 {
-                return Err(eof());
-            }
-            offset += n as u64;
-            buf = &mut buf[n..];
-        }
-        Ok(())
-    }
-    #[cfg(not(any(unix, windows)))]
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        let mut f = self;
-        f.seek(SeekFrom::Start(offset))?;
-        f.read_exact(buf)
-    }
-}
-
-/// Adapts any `Read + Seek` (e.g. `BufReader<File>`, `Cursor<Vec<u8>>`) into a [`ByteSource`].
-///
-/// The length is taken once at construction; the stream position is tracked so sequential reads
-/// do not issue redundant seeks.
-pub struct ReadSeekSource<R> {
-    inner: RefCell<(R, u64)>,
-    len: u64,
-}
-
-impl<R: Read + Seek> ReadSeekSource<R> {
-    /// Wrap a reader; seeks to the end once to learn the length.
-    pub fn new(mut r: R) -> io::Result<Self> {
-        let len = r.seek(SeekFrom::End(0))?;
-        Ok(Self { inner: RefCell::new((r, len)), len })
-    }
-    /// Unwrap the reader.
-    pub fn into_inner(self) -> R {
-        self.inner.into_inner().0
-    }
-}
-
-impl<R: Read + Seek> ByteSource for ReadSeekSource<R> {
-    fn len(&self) -> u64 {
-        self.len
-    }
-    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
-        if offset.checked_add(buf.len() as u64).is_none_or(|e| e > self.len) {
-            return Err(eof());
-        }
-        let mut g = self.inner.borrow_mut();
-        let (r, pos) = &mut *g;
-        if *pos != offset {
-            r.seek(SeekFrom::Start(offset))?;
-            *pos = offset;
-        }
-        let res = r.read_exact(buf);
-        match res {
-            Ok(()) => {
-                *pos = offset + buf.len() as u64;
-                Ok(())
-            }
-            Err(e) => {
-                *pos = u64::MAX; // unknown; force a seek next time
-                Err(e)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn slice_and_reader_sources() {
-        let v = vec![1u8, 2, 3, 4];
-        let mut b = [0u8; 2];
-        v.read_at(1, &mut b).unwrap();
-        assert_eq!(b, [2, 3]);
-        assert!(v.read_at(3, &mut b).is_err());
-        assert!(v.read_at(u64::MAX, &mut b).is_err());
-        let r = ReadSeekSource::new(io::Cursor::new(v.clone())).unwrap();
-        assert_eq!(r.len(), 4);
-        r.read_at(2, &mut b).unwrap();
-        assert_eq!(b, [3, 4]);
-        r.read_at(0, &mut b).unwrap();
-        assert_eq!(b, [1, 2]);
-        assert!(r.read_at(3, &mut b).is_err());
-    }
-}
@@ -1,254 +0,0 @@
-//! Hand-built files exercising features FFmpeg does not write: unknown-size Segment/Clusters,
-//! header stripping, BlockGroups, Colour + mastering metadata, Chapters, Tags, Attachments, CRC-32.
-
-use crate::codec::Codec;
-use crate::ebml::{self, write_id, write_unknown_size};
-use crate::ids::*;
-use crate::mux::{el, el_float, el_str, el_uint};
-use crate::track::ContentEncoding;
-use crate::{Demuxer, OpenOptions, Packet, open_with};
-
-fn block(track: u8, rel: i16, flags: u8, data: &[u8]) -> Vec<u8> {
-    let mut b = vec![0x80 | track];
-    b.extend_from_slice(&rel.to_be_bytes());
-    b.push(flags);
-    b.extend_from_slice(data);
-    b
-}
-
-fn synthetic() -> Vec<u8> {
-    let mut f = Vec::new();
-    let mut h = Vec::new();
-    el_str(&mut h, DOC_TYPE, "matroska");
-    el_uint(&mut h, DOC_TYPE_VERSION, 4);
-    el(&mut f, EBML, &h);
-    write_id(&mut f, SEGMENT);
-    write_unknown_size(&mut f, 8);
-    // Info with a correct CRC-32 and a Void
-    let mut info = Vec::new();
-    el_uint(&mut info, TIMESTAMP_SCALE, 1_000_000);
-    el_str(&mut info, TITLE, "Synthetic");
-    el(&mut info, VOID, &[0; 3]);
-    let mut crc_info = Vec::new();
-    el(&mut crc_info, CRC32, &ebml::crc32(&info).to_le_bytes());
-    crc_info.extend_from_slice(&info);
-    el(&mut f, INFO, &crc_info);
-    // Tracks
-    let mut v = Vec::new();
-    el_uint(&mut v, TRACK_NUMBER, 1);
-    el_uint(&mut v, TRACK_UID, 11);
-    el_uint(&mut v, TRACK_TYPE, 1);
-    el_str(&mut v, CODEC_ID, "V_MPEG4/ISO/AVC");
-    el(&mut v, CODEC_PRIVATE, &[1, 0x64, 0, 0x1F]);
-    el_uint(&mut v, DEFAULT_DURATION, 40_000_000);
-    let mut mm = Vec::new();
-    for (id, val) in
-        [(PRIMARY_R_X, 0.708), (PRIMARY_R_Y, 0.292), (PRIMARY_G_X, 0.17), (PRIMARY_G_Y, 0.797), (PRIMARY_B_X, 0.131), (PRIMARY_B_Y, 0.046)]
-    {
-        el_float(&mut mm, id, val);
-    }
-    el_float(&mut mm, WHITE_POINT_X, 0.3127);
-    el_float(&mut mm, WHITE_POINT_Y, 0.329);
-    el_float(&mut mm, LUMINANCE_MAX, 1000.0);
-    el_float(&mut mm, LUMINANCE_MIN, 0.0001);
-    let mut col = Vec::new();
-    el_uint(&mut col, MATRIX_COEFFICIENTS, 9);
-    el_uint(&mut col, RANGE, 2);
-    el_uint(&mut col, TRANSFER_CHARACTERISTICS, 16);
-    el_uint(&mut col, PRIMARIES, 9);
-    el_uint(&mut col, MAX_CLL, 1000);
-    el_uint(&mut col, MAX_FALL, 400);
-    el(&mut col, MASTERING_METADATA, &mm);
-    let mut vid = Vec::new();
-    el_uint(&mut vid, PIXEL_WIDTH, 1440);
-    el_uint(&mut vid, PIXEL_HEIGHT, 1080);
-    el_uint(&mut vid, DISPLAY_WIDTH, 1920);
-    el_uint(&mut vid, DISPLAY_HEIGHT, 1080);
-    el(&mut vid, COLOUR, &col);
-    // rectangular, a quarter turn clockwise (portrait phone video)
-    let mut proj = Vec::new();
-    el_uint(&mut proj, PROJECTION_TYPE, 0);
-    el_float(&mut proj, PROJECTION_POSE_ROLL, -90.0);
-    el(&mut vid, PROJECTION, &proj);
-    el(&mut v, VIDEO, &vid);
-    // header stripping: every frame starts with 00 00 00 01
-    let mut comp = Vec::new();
-    el_uint(&mut comp, CONTENT_COMP_ALGO, 3);
-    el(&mut comp, CONTENT_COMP_SETTINGS, &[0, 0, 0, 1]);
-    let mut enc = Vec::new();
-    el(&mut enc, CONTENT_COMPRESSION, &comp);
-    let mut encs = Vec::new();
-    el(&mut encs, CONTENT_ENCODING, &enc);
-    el(&mut v, CONTENT_ENCODINGS, &encs);
-    let mut a = Vec::new();
-    el_uint(&mut a, TRACK_NUMBER, 2);
-    el_uint(&mut a, TRACK_TYPE, 2);
-    el_str(&mut a, CODEC_ID, "A_AAC/MPEG4/LC/SBR");
-    el_str(&mut a, LANGUAGE, "ger");
-    let mut au = Vec::new();
-    el_float(&mut au, SAMPLING_FREQUENCY, 24000.0);
-    el_float(&mut au, OUTPUT_SAMPLING_FREQUENCY, 48000.0);
-    el_uint(&mut au, CHANNELS, 2);
-    el(&mut a, AUDIO, &au);
-    let mut tr = Vec::new();
-    el(&mut tr, TRACK_ENTRY, &v);
-    el(&mut tr, TRACK_ENTRY, &a);
-    el(&mut f, TRACKS, &tr);
-    // Chapters
-    let mut disp = Vec::new();
-    el_str(&mut disp, CHAP_STRING, "Intro");
-    let mut atom = Vec::new();
-    el_uint(&mut atom, CHAPTER_UID, 5);
-    el_uint(&mut atom, CHAPTER_TIME_START, 0);
-    el_uint(&mut atom, CHAPTER_TIME_END, 40_000_000);
-    el(&mut atom, CHAPTER_DISPLAY, &disp);
-    let mut ed = Vec::new();
-    el(&mut ed, CHAPTER_ATOM, &atom);
-    let mut ch = Vec::new();
-    el(&mut ch, EDITION_ENTRY, &ed);
-    el(&mut f, CHAPTERS, &ch);
-    // Attachments
-    let mut af = Vec::new();
-    el_str(&mut af, FILE_NAME, "font.ttf");
-    el_str(&mut af, FILE_MEDIA_TYPE, "font/ttf");
-    el_uint(&mut af, FILE_UID, 77);
-    el(&mut af, FILE_DATA, &[9; 100]);
-    let mut att = Vec::new();
-    el(&mut att, ATTACHED_FILE, &af);
-    el(&mut f, ATTACHMENTS, &att);
-    // Cluster 1 (unknown size): keyframe SimpleBlock, BlockGroup with ReferenceBlock + duration
-    write_id(&mut f, CLUSTER);
-    write_unknown_size(&mut f, 1);
-    el_uint(&mut f, TIMESTAMP, 1000);
-    el(&mut f, SIMPLE_BLOCK, &block(1, 0, 0x80, &[0x65, 1, 2]));
-    el(&mut f, SIMPLE_BLOCK, &block(2, 5, 0x80, &[0xAA; 10]));
-    let mut g = Vec::new();
-    el(&mut g, BLOCK, &block(1, 40, 0, &[0x41, 3]));
-    el(&mut g, REFERENCE_BLOCK, &[0xD8]);
-    el_uint(&mut g, BLOCK_DURATION, 80);
-    el(&mut f, BLOCK_GROUP, &g);
-    el(&mut f, SIMPLE_BLOCK, &block(9, 0, 0x80, &[1])); // unknown track: ignored
-    // Cluster 2 (unknown size), ended by Tags
-    write_id(&mut f, CLUSTER);
-    write_unknown_size(&mut f, 8);
-    el_uint(&mut f, TIMESTAMP, 1120);
-    el(&mut f, SIMPLE_BLOCK, &block(1, 0, 0x80, &[0x65, 4]));
-    let mut st = Vec::new();
-    el_str(&mut st, TAG_NAME, "ARTIST");
-    el_str(&mut st, TAG_STRING, "Nobody");
-    let mut tg = Vec::new();
-    let mut tgt = Vec::new();
-    el_uint(&mut tgt, TAG_TRACK_UID, 11);
-    el(&mut tg, TARGETS, &tgt);
-    el(&mut tg, SIMPLE_TAG, &st);
-    let mut tags = Vec::new();
-    el(&mut tags, TAG, &tg);
-    el(&mut f, TAGS, &tags);
-    f
-}
-
-#[test]
-fn synthetic_file() {
-    let bytes = synthetic();
-    let f = open_with(&bytes[..], &OpenOptions { index: true, verify_crc: true }).unwrap();
-    assert!(f.live);
-    assert!(f.warnings.is_empty(), "{:?}", f.warnings);
-    assert_eq!((f.crc_checked, f.crc_errors.len()), (1, 0));
-    assert_eq!(f.info.title.as_deref(), Some("Synthetic"));
-    let v = &f.tracks[0];
-    assert!(matches!(&v.codec, Codec::Avc { avcc } if avcc[1] == 0x64));
-    let vi = v.video.as_ref().unwrap();
-    assert_eq!(vi.pixel_aspect(), (4, 3));
-    assert_eq!(vi.projection.as_ref().map(|p| p.roll), Some(-90.0));
-    assert_eq!(vi.display_rotation(), Some(1));
-    let c = vi.colour.as_ref().unwrap();
-    assert!(c.full_range());
-    assert_eq!(
-        (c.matrix_coefficients, c.transfer_characteristics, c.primaries, c.max_cll, c.max_fall),
-        (Some(9), Some(16), Some(9), Some(1000), Some(400))
-    );
-    let m = c.mastering.as_ref().unwrap();
-    assert_eq!(m.primaries[1], (0.17, 0.797));
-    assert_eq!(m.white_point, (0.3127, 0.329));
-    assert_eq!((m.luminance_max, m.luminance_min), (1000.0, 0.0001));
-    assert_eq!(v.encodings, vec![ContentEncoding::HeaderStripping { bytes: vec![0, 0, 0, 1], scope: 1 }]);
-    // legacy AAC ID: ASC synthesised with explicit SBR signalling (LC, 24 kHz, stereo → 48 kHz)
-    assert_eq!(f.tracks[1].codec, Codec::Aac { asc: vec![0x13, 0x10, 0x56, 0xE5, 0x98] });
-    assert_eq!(f.tracks[1].language, "ger");
-    assert_eq!(f.chapters[0].chapters[0].title(), Some("Intro"));
-    assert_eq!(f.chapters[0].chapters[0].end_ns, Some(40_000_000));
-    assert_eq!(f.attachments.len(), 1);
-    let at = &f.attachments[0];
-    assert_eq!((at.name.as_str(), at.media_type.as_str(), at.uid), ("font.ttf", "font/ttf", 77));
-    assert_eq!(&bytes[at.data_offset as usize..][..100], &[9; 100]);
-    assert_eq!(f.tags[0].targets.track_uids, vec![11]);
-    assert_eq!(f.tags[0].simple[0].string.as_deref(), Some("Nobody"));
-    assert_eq!(f.clusters.len(), 2);
-    assert_eq!(v.samples.len(), 3);
-    assert_eq!(v.keyframes(), &[0, 2]);
-
-    let d = Demuxer::from_slice(&bytes).unwrap();
-    let p: Vec<Packet> = d.map(|p| p.unwrap()).collect();
-    assert_eq!(p.len(), 4);
-    assert_eq!((p[0].track, p[0].pts, p[0].keyframe, p[0].duration), (0, 1000, true, 40));
-    assert_eq!(p[0].data, [0, 0, 0, 1, 0x65, 1, 2]);
-    assert_eq!((p[1].track, p[1].pts, p[1].data.len()), (1, 1005, 10));
-    assert_eq!((p[2].pts, p[2].keyframe, p[2].duration), (1040, false, 80));
-    assert_eq!(p[2].data, [0, 0, 0, 1, 0x41, 3]);
-    assert_eq!((p[3].pts, p[3].pts_ns), (1120, 1_120_000_000));
-    assert_eq!(f.read_sample(&bytes[..], 0, 1).unwrap(), p[2].data);
-
-    // CRC mismatch is reported, not fatal
-    let mut bad = bytes.clone();
-    let title = bad.windows(9).position(|w| w == b"Synthetic").unwrap();
-    bad[title] = b's';
-    let f = open_with(&bad[..], &OpenOptions { index: true, verify_crc: true }).unwrap();
-    assert_eq!(f.crc_errors.len(), 1);
-
-    // seeking without index or cues builds the index
-    let mut d = Demuxer::with_options(&bytes[..], OpenOptions { index: false, verify_crc: false }).unwrap();
-    assert_eq!(d.file().tracks.len(), 2);
-    assert_eq!(d.seek(0, 1_100_000_000).unwrap().pts, 1000);
-    assert_eq!(d.seek(0, 1_130_000_000).unwrap().pts, 1120);
-    assert_eq!(d.next_packet().unwrap().unwrap().pts, 1120);
-    assert!(d.file().indexed);
-}
-
-fn one_block(ts: u64, rel: i16) -> Vec<u8> {
-    let mut f = Vec::new();
-    let mut h = Vec::new();
-    el_str(&mut h, DOC_TYPE, "matroska");
-    el(&mut f, EBML, &h);
-    write_id(&mut f, SEGMENT);
-    write_unknown_size(&mut f, 8);
-    let mut info = Vec::new();
-    el_uint(&mut info, TIMESTAMP_SCALE, 1_000_000);
-    el(&mut f, INFO, &info);
-    let mut v = Vec::new();
-    el_uint(&mut v, TRACK_NUMBER, 1);
-    el_uint(&mut v, TRACK_UID, 1);
-    el_uint(&mut v, TRACK_TYPE, 1);
-    el_str(&mut v, CODEC_ID, "V_UNCOMPRESSED");
-    let mut tr = Vec::new();
-    el(&mut tr, TRACK_ENTRY, &v);
-    el(&mut f, TRACKS, &tr);
-    write_id(&mut f, CLUSTER);
-    write_unknown_size(&mut f, 8);
-    el_uint(&mut f, TIMESTAMP, ts);
-    el(&mut f, SIMPLE_BLOCK, &block(1, rel, 0x80, &[0]));
-    f
-}
-
-#[test]
-fn block_timestamp_addition_does_not_overflow() {
-    let bytes = one_block(1000, 5);
-    let d = Demuxer::from_slice(&bytes).unwrap();
-    let p: Vec<Packet> = d.map(|p| p.unwrap()).collect();
-    assert_eq!(p[0].pts, 1005);
-    let edge = one_block(i64::MAX as u64, 0);
-    let d = Demuxer::from_slice(&edge).unwrap();
-    let p: Vec<Packet> = d.map(|p| p.unwrap()).collect();
-    assert_eq!(p[0].pts, i64::MAX);
-    assert!(Demuxer::from_slice(&one_block(i64::MAX as u64, 1)).is_err());
-    assert!(Demuxer::from_slice(&one_block(u64::MAX, 0)).is_err());
-}
@@ -1,348 +0,0 @@
-//! Track descriptions (RFC 9559 §5.1.4).
-
-use crate::codec::Codec;
-
-/// Track type (`TrackType`).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TrackKind {
-    Video,
-    Audio,
-    Complex,
-    Logo,
-    Subtitle,
-    Buttons,
-    Control,
-    Metadata,
-    Other(u8),
-}
-
-impl TrackKind {
-    pub(crate) fn from_type(t: u64) -> TrackKind {
-        match t {
-            1 => TrackKind::Video,
-            2 => TrackKind::Audio,
-            3 => TrackKind::Complex,
-            0x10 => TrackKind::Logo,
-            0x11 => TrackKind::Subtitle,
-            0x12 => TrackKind::Buttons,
-            0x20 => TrackKind::Control,
-            0x21 => TrackKind::Metadata,
-            n => TrackKind::Other(n as u8),
-        }
-    }
-}
-
-/// SMPTE ST 2086 mastering display metadata (`MasteringMetadata`). Chromaticities are CIE 1931 xy,
-/// luminance in cd/m².
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct MasteringMetadata {
-    /// Red, green, blue primaries as (x, y).
-    pub primaries: [(f64, f64); 3],
-    pub white_point: (f64, f64),
-    pub luminance_max: f64,
-    pub luminance_min: f64,
-}
-
-/// `Colour` element. Code points use ITU-T H.273 values (as Matroska does).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Colour {
-    /// `MatrixCoefficients` (H.273; 2 = unspecified).
-    pub matrix_coefficients: Option<u64>,
-    pub bits_per_channel: Option<u64>,
-    pub chroma_subsampling_horz: Option<u64>,
-    pub chroma_subsampling_vert: Option<u64>,
-    pub cb_subsampling_horz: Option<u64>,
-    pub cb_subsampling_vert: Option<u64>,
-    pub chroma_siting_horz: Option<u64>,
-    pub chroma_siting_vert: Option<u64>,
-    /// `Range`: 0 unspecified, 1 broadcast (limited), 2 full, 3 defined by matrix/transfer.
-    pub range: Option<u64>,
-    /// `TransferCharacteristics` (H.273).
-    pub transfer_characteristics: Option<u64>,
-    /// `Primaries` (H.273).
-    pub primaries: Option<u64>,
-    /// Maximum content light level (cd/m²).
-    pub max_cll: Option<u64>,
-    /// Maximum frame-average light level (cd/m²).
-    pub max_fall: Option<u64>,
-    pub mastering: Option<MasteringMetadata>,
-}
-
-impl Colour {
-    /// True if `Range` says full range.
-    pub fn full_range(&self) -> bool {
-        self.range == Some(2)
-    }
-}
-
-/// `Video` element.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct VideoInfo {
-    pub pixel_width: u32,
-    pub pixel_height: u32,
-    /// `DisplayWidth`/`DisplayHeight`, in `display_unit` (0 = pixels, 3 = display aspect ratio).
-    pub display_width: Option<u32>,
-    pub display_height: Option<u32>,
-    pub display_unit: u64,
-    /// Crop (top, bottom, left, right) in pixels.
-    pub crop: (u32, u32, u32, u32),
-    /// `FlagInterlaced`: 0 undetermined, 1 interlaced, 2 progressive.
-    pub flag_interlaced: u64,
-    /// `FieldOrder` (0 progressive, 1 tff, 2 undetermined, 6 bff, 9/14 interleaved).
-    pub field_order: Option<u64>,
-    pub stereo_mode: Option<u64>,
-    /// `AlphaMode`: 1 if BlockAdditions carry alpha.
-    pub alpha_mode: u64,
-    /// `ColourSpace` FourCC (uncompressed video).
-    pub colour_space: Option<[u8; 4]>,
-    pub colour: Option<Colour>,
-    pub projection: Option<Projection>,
-}
-
-/// `Projection` element (RFC 9559 §5.1.4.1.28.41): pose angles in degrees.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Projection {
-    /// 0 rectangular, 1 equirectangular, 2 cubemap, 3 mesh.
-    pub projection_type: u64,
-    /// Clockwise around the up vector.
-    pub yaw: f64,
-    /// Counter-clockwise around the right vector.
-    pub pitch: f64,
-    /// Counter-clockwise around the forward vector.
-    pub roll: f64,
-}
-
-impl VideoInfo {
-    /// Clockwise quarter turns (0–3) to display a rectangular video, from `ProjectionPoseRoll`
-    /// (a counter-clockwise angle, so −90 is a quarter turn clockwise). None for other
-    /// projections, flips (non-zero yaw / pitch) or angles that are not a multiple of 90°.
-    pub fn display_rotation(&self) -> Option<u8> {
-        let Some(p) = &self.projection else { return Some(0) };
-        if p.projection_type != 0 || p.yaw != 0.0 || p.pitch != 0.0 || p.roll % 90.0 != 0.0 {
-            return None;
-        }
-        Some((-(p.roll / 90.0) as i64).rem_euclid(4) as u8)
-    }
-
-    /// Pixel aspect ratio derived from the display size (pixels or aspect-ratio units), reduced.
-    pub fn pixel_aspect(&self) -> (u32, u32) {
-        let (pw, ph) =
-            (self.pixel_width.saturating_sub(self.crop.2 + self.crop.3) as u64, self.pixel_height.saturating_sub(self.crop.0 + self.crop.1) as u64);
-        let (Some(dw), Some(dh)) = (self.display_width, self.display_height) else { return (1, 1) };
-        if pw == 0 || ph == 0 || dw == 0 || dh == 0 || !matches!(self.display_unit, 0 | 3) {
-            return (1, 1);
-        }
-        // PAR = (dw/dh) / (pw/ph)
-        let (n, d) = (dw as u64 * ph, dh as u64 * pw);
-        let g = gcd(n, d);
-        ((n / g) as u32, (d / g) as u32)
-    }
-}
-
-pub(crate) fn gcd(mut a: u64, mut b: u64) -> u64 {
-    while b != 0 {
-        (a, b) = (b, a % b);
-    }
-    a.max(1)
-}
-
-/// `Audio` element.
-#[derive(Clone, Debug, PartialEq)]
-pub struct AudioInfo {
-    /// `SamplingFrequency` (Hz).
-    pub sampling_frequency: f64,
-    /// `OutputSamplingFrequency` (e.g. SBR output rate).
-    pub output_sampling_frequency: Option<f64>,
-    pub channels: u64,
-    pub bit_depth: Option<u64>,
-}
-
-impl Default for AudioInfo {
-    fn default() -> Self {
-        Self { sampling_frequency: 8000.0, output_sampling_frequency: None, channels: 1, bit_depth: None }
-    }
-}
-
-/// One `ContentEncoding`.
-#[derive(Clone, Debug, PartialEq)]
-pub enum ContentEncoding {
-    /// `ContentCompAlgo` 3: the given bytes were stripped from the start of every frame.
-    HeaderStripping { bytes: Vec<u8>, scope: u64 },
-    /// Other compression (0 zlib, 1 bzlib, 2 lzo1x): not supported for reading frame data.
-    Compression { algo: u64, settings: Vec<u8>, scope: u64 },
-    /// Encryption (not supported for reading frame data).
-    Encryption { scope: u64 },
-}
-
-/// One entry of a track's sample (frame) table.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Sample {
-    /// Byte offset of the (stored) frame data in the file.
-    pub offset: u64,
-    /// Stored size (excluding header-stripped bytes; see [`Track::sample_size`]).
-    pub size: u32,
-    /// Presentation timestamp in the track timebase (`TimestampScale` ticks).
-    pub pts: i64,
-    /// Duration in timebase ticks (from `BlockDuration` or `DefaultDuration`), 0 if unknown.
-    pub duration: u64,
-    pub keyframe: bool,
-    /// Index of the owning cluster in [`crate::MkvFile::clusters`].
-    pub cluster: u32,
-    /// Offset of the block element (SimpleBlock / BlockGroup) header.
-    pub block_offset: u64,
-    /// Index of this frame within a laced block.
-    pub lace: u16,
-}
-
-/// A Matroska track (`TrackEntry`) plus, once indexed, its sample table.
-#[derive(Clone, Debug)]
-pub struct Track {
-    pub number: u64,
-    pub uid: u64,
-    pub kind: TrackKind,
-    pub enabled: bool,
-    pub default: bool,
-    pub forced: bool,
-    pub hearing_impaired: bool,
-    pub lacing: bool,
-    /// `DefaultDuration` in nanoseconds.
-    pub default_duration_ns: Option<u64>,
-    pub name: String,
-    /// `Language` (ISO 639-2, default `eng`).
-    pub language: String,
-    pub language_bcp47: Option<String>,
-    pub codec_id: String,
-    pub codec_private: Vec<u8>,
-    pub codec_name: String,
-    pub codec: Codec,
-    /// `CodecDelay` in nanoseconds.
-    pub codec_delay_ns: u64,
-    /// `SeekPreRoll` in nanoseconds.
-    pub seek_pre_roll_ns: u64,
-    pub video: Option<VideoInfo>,
-    pub audio: Option<AudioInfo>,
-    pub encodings: Vec<ContentEncoding>,
-    /// Timebase numerator/denominator in seconds: `TimestampScale / 1e9`, reduced.
-    pub timebase: (u64, u64),
-    /// Frame table (empty unless the file was opened with indexing).
-    pub samples: Vec<Sample>,
-    pub(crate) sync: Vec<u32>,
-}
-
-impl Track {
-    /// Bytes prepended to every frame by header-stripping compression, if any.
-    pub fn stripped_header(&self) -> Option<&[u8]> {
-        self.encodings.iter().find_map(|e| match e {
-            ContentEncoding::HeaderStripping { bytes, scope } if scope & 1 != 0 => Some(bytes.as_slice()),
-            _ => None,
-        })
-    }
-
-    /// True if frames can be returned verbatim or with header stripping undone.
-    pub fn frames_readable(&self) -> bool {
-        self.encodings.iter().all(|e| match e {
-            ContentEncoding::HeaderStripping { .. } => true,
-            ContentEncoding::Compression { scope, .. } | ContentEncoding::Encryption { scope } => scope & 1 == 0,
-        })
-    }
-
-    /// Bytes to put in front of a stored frame of `stored_size` bytes to get the codec frame:
-    /// header-stripped bytes, or for `V_PRORES` the 8-byte frame header (`size` + `icpf`) that the
-    /// Matroska ProRes mapping omits.
-    pub fn frame_prefix(&self, stored_size: u64) -> Vec<u8> {
-        let mut p = self.stripped_header().map(<[u8]>::to_vec).unwrap_or_default();
-        if matches!(self.codec, Codec::ProRes { .. }) {
-            let total = stored_size + p.len() as u64 + 8;
-            let mut h = (total as u32).to_be_bytes().to_vec();
-            h.extend_from_slice(b"icpf");
-            h.extend_from_slice(&p);
-            p = h;
-        }
-        p
-    }
-
-    /// Frame size of sample `i` as returned by `read_sample` / packets (stored size plus prefix).
-    pub fn sample_size(&self, i: usize) -> Option<u64> {
-        let s = self.samples.get(i)?;
-        Some(s.size as u64 + self.frame_prefix(s.size as u64).len() as u64)
-    }
-
-    /// Indices of keyframe samples, ascending by file order.
-    pub fn keyframes(&self) -> &[u32] {
-        &self.sync
-    }
-
-    /// Timebase ticks → nanoseconds.
-    pub fn ticks_to_ns(&self, t: i64) -> i64 {
-        (t as i128 * self.timebase.0 as i128 * 1_000_000_000 / self.timebase.1 as i128) as i64
-    }
-
-    /// Nanoseconds → timebase ticks (floor).
-    pub fn ns_to_ticks(&self, ns: i64) -> i64 {
-        let n = ns as i128 * self.timebase.1 as i128;
-        let d = self.timebase.0 as i128 * 1_000_000_000;
-        n.div_euclid(d) as i64
-    }
-
-    /// Index of the last sample with `pts <= t` (in file order), or the first sample.
-    pub fn sample_at_pts(&self, t: i64) -> Option<usize> {
-        if self.samples.is_empty() {
-            return None;
-        }
-        let mut best: Option<usize> = None;
-        for (i, s) in self.samples.iter().enumerate() {
-            if s.pts <= t && best.is_none_or(|b| s.pts >= self.samples[b].pts) {
-                best = Some(i);
-            }
-        }
-        Some(best.unwrap_or(0))
-    }
-
-    /// Index of the keyframe with the greatest `pts <= t` (the first keyframe if none precedes `t`).
-    pub fn keyframe_before_pts(&self, t: i64) -> Option<usize> {
-        let mut best: Option<usize> = None;
-        for &k in &self.sync {
-            let s = &self.samples[k as usize];
-            if s.pts <= t && best.is_none_or(|b| s.pts >= self.samples[b].pts) {
-                best = Some(k as usize);
-            }
-        }
-        best.or_else(|| self.sync.first().map(|&k| k as usize))
-    }
-
-    /// Index of the nearest keyframe at or before sample `index` in file order.
-    pub fn sync_sample_before(&self, index: usize) -> usize {
-        match self.sync.binary_search(&(index as u32)) {
-            Ok(i) => self.sync[i] as usize,
-            Err(0) => 0,
-            Err(i) => self.sync[i - 1] as usize,
-        }
-    }
-}
-
-#[cfg(test)]
-mod rotation_tests {
-    use super::{Projection, VideoInfo};
-
-    fn with_roll(projection_type: u64, yaw: f64, pitch: f64, roll: f64) -> VideoInfo {
-        VideoInfo { projection: Some(Projection { projection_type, yaw, pitch, roll }), ..Default::default() }
-    }
-
-    #[test]
-    fn display_rotation_maps_rectangular_roll_to_clockwise_quarter_turns() {
-        assert_eq!(VideoInfo::default().display_rotation(), Some(0), "no Projection: as stored");
-        // ProjectionPoseRoll is counter-clockwise: -90 is a quarter turn clockwise
-        for (roll, turns) in [(0.0, 0), (-90.0, 1), (180.0, 2), (-180.0, 2), (90.0, 3), (-270.0, 3), (270.0, 1), (360.0, 0)] {
-            assert_eq!(with_roll(0, 0.0, 0.0, roll).display_rotation(), Some(turns), "roll {roll}");
-        }
-    }
-
-    #[test]
-    fn display_rotation_leaves_non_rectangular_flipped_and_odd_angles_alone() {
-        assert_eq!(with_roll(1, 0.0, 0.0, -90.0).display_rotation(), None, "equirectangular");
-        assert_eq!(with_roll(0, 180.0, 0.0, 0.0).display_rotation(), None, "yaw flip");
-        assert_eq!(with_roll(0, 0.0, 180.0, 0.0).display_rotation(), None, "pitch flip");
-        assert_eq!(with_roll(0, 0.0, 0.0, 45.0).display_rotation(), None, "not a quarter turn");
-        assert_eq!(with_roll(0, 0.0, 0.0, f64::NAN).display_rotation(), None, "malformed angle");
-    }
-}
@@ -2,8 +2,6 @@
 //! protocol, files open and load only from inside the read root and are saved and exported only
 //! inside the write root. Paths that leave a root (`..`, another folder, a sibling with the same
 //! prefix, a link) are refused, and nothing is written outside.
-// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md).
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]

 use std::path::{Path, PathBuf};

@@ -0,0 +1,3 @@
+// Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md).
+#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+mod automation_roots;
@@ -22,4 +22,4 @@ log = { workspace = true }
 image = { workspace = true }
 # Audio decoding for the formats we have no decoder of our own for (MPL-2.0, used unmodified,
 # as in FilmCraft).
-symphonia = { version = "0.5.5", default-features = false, features = ["aac", "adpcm", "alac", "flac", "mp1", "mp2", "mp3", "pcm", "vorbis", "wav", "aiff", "caf", "ogg", "mkv", "isomp4"] }
+symphonia = { version = "0.6.1", default-features = false, features = ["aac", "adpcm", "alac", "flac", "mp1", "mp2", "mp3", "pcm", "vorbis", "wav", "aiff", "caf", "ogg", "mkv", "isomp4"] }
@@ -31,7 +31,7 @@ pub use audio::Pcm;
 pub use clip::ClipParams;
 pub use feed::VideoFeed;
 pub use player::{AudioOut, PlayState, Player, VoiceSpec, VoiceStatus};
-pub use probe::{AudioInfo, MediaInfo, VideoInfo, probe};
+pub use probe::{AudioInfo, MediaInfo, VideoInfo, probe, probe_headers};
 pub use video::{Frame, VideoDecoder, poster_frame, poster_png};

 /// Shared media bytes (the model's `MediaItem::data`).
@@ -48,6 +48,19 @@ fn ms(secs: f64) -> u64 {

 /// Probe `bytes`.
 pub fn probe(bytes: &Bytes) -> Result<MediaInfo> {
+    let mut info = probe_headers(bytes)?;
+    if info.duration_ms == 0 && info.audio.as_ref().is_some_and(|a| a.decodable) && info.video.is_none() {
+        // No length in the header (raw MP3 / ADTS without an index): decode to measure.
+        if let Ok(pcm) = crate::audio::decode(bytes) {
+            info.duration_ms = ms(pcm.duration());
+        }
+    }
+    Ok(info)
+}
+
+/// [`probe`] from the headers alone, without decoding: a raw MP3 or ADTS stream without an
+/// index reports a `duration_ms` of 0.
+pub fn probe_headers(bytes: &Bytes) -> Result<MediaInfo> {
    let c = Container::sniff(bytes);
    let mut info = match c {
        Container::Mp4 => probe_mp4(bytes)?,
@@ -73,12 +86,6 @@ pub fn probe(bytes: &Bytes) -> Result<MediaInfo> {
            info.duration_ms = ms(n as f64 / rate as f64);
        }
    }
-    if info.duration_ms == 0 && info.audio.as_ref().is_some_and(|a| a.decodable) && info.video.is_none() {
-        // No length in the header (raw MP3 / ADTS without an index): decode to measure.
-        if let Ok(pcm) = crate::audio::decode(bytes) {
-            info.duration_ms = ms(pcm.duration());
-        }
-    }
    Ok(info)
 }

@@ -330,6 +330,7 @@ pub(crate) fn codec_name(c: &CodecConfig) -> String {
        CodecConfig::Hevc(_) => "HEVC".into(),
        CodecConfig::Av1(_) => "AV1".into(),
        CodecConfig::Vp9(_) => "VP9".into(),
+        CodecConfig::Apv(_) => "APV".into(),
        CodecConfig::ProRes { .. } => "Apple ProRes".into(),
        CodecConfig::Jpeg { .. } => "Motion JPEG".into(),
        CodecConfig::Dnx { .. } => "DNxHD".into(),
@@ -20,12 +20,13 @@ $FF $TONE44 -c:a wmav2 -b:a 64k $META tone.wma
 # Video: 64x48 (AV1: 64x64), 10 fps, 6 frames of our own moving colour gradient (raw RGB from
 # python3 below), so every pixel is contributor-original.
 frames() {
+  width="$1" height="$2" out="$3"
  python3 -c "
 import sys
-w, h = $1, $2
+w, h = $width, $height
 for f in range(6):
    sys.stdout.buffer.write(bytes(v for y in range(h) for x in range(w) for v in ((x * 4 + f * 20) % 256, (y * 5) % 256, (f * 40) % 256)))
-" > "$3"
+" > "$out"
 }
 frames 64 48 /tmp/deckcraft-fixture-64x48.rgb
 frames 64 64 /tmp/deckcraft-fixture-64x64.rgb
@@ -0,0 +1 @@
+mod decode;
@@ -1132,7 +1132,14 @@ impl Chart {
            let sd = (v.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / (n - 1.0).max(1.0)).sqrt();
            3.49 * sd / n.cbrt()
        };
-        let count = if span <= 0.0 || !width.is_finite() || width <= 0.0 { 1 } else { ((span / width).ceil() as usize).clamp(1, MAX_BINS) };
+        let fixed = self.bin_count.filter(|k| *k > 0).filter(|_| self.bin_size.filter(|w| w.is_finite() && *w > 0.0).is_none());
+        let count = if span <= 0.0 || !width.is_finite() || width <= 0.0 {
+            1
+        } else if let Some(k) = fixed {
+            (k as usize).clamp(1, MAX_BINS)
+        } else {
+            ((span / width).ceil() as usize).clamp(1, MAX_BINS)
+        };
        let width = if count == 1 && (span <= 0.0 || !width.is_finite() || width <= 0.0) { span.max(1.0) } else { width.max(span / MAX_BINS as f64) };
        let mut bins: Vec<Bin> = (0..count).map(|i| Bin { lo: lo + width * i as f64, hi: lo + width * (i + 1) as f64, count: 0 }).collect();
        for x in v {
@@ -1389,6 +1396,13 @@ mod chartex_tests {
        assert!(obs(&[]).histogram_bins().is_empty());
    }

+    #[test]
+    fn histogram_fixed_bin_count_is_exact_despite_float_rounding() {
+        let mut c = obs(&[0.0, 1.0, 2.1]);
+        c.bin_count = Some(7);
+        assert_eq!(c.histogram_bins().len(), 7);
+    }
+
    #[test]
    fn pareto_view_sorts_bins_and_adds_the_cumulative_line() {
        let mut c = obs(&[1.0, 5.0, 5.0, 5.0, 9.0, 9.0]);
@@ -231,6 +231,8 @@ pub struct MediaClip {
    pub video: bool,
    /// Poster frame image.
    pub poster: Option<MediaId>,
+    /// Crop of the picture (left, top, right, bottom as fractions), PowerPoint's `srcRect` on the video.
+    pub crop: [f64; 4],
    pub trim_start_ms: u32,
    pub trim_end_ms: u32,
    pub fade_in_ms: u32,
@@ -439,6 +441,11 @@ impl Default for Shape {
 }

 impl Shape {
+    /// A stand-in shape for laying out one table cell's `body`: a table, so the cell's text takes
+    /// the master's other-text style as PowerPoint's does.
+    pub fn table_cell(body: text::TextBody) -> Shape {
+        Shape { text: Some(body), kind: ShapeKind::Table(Table::default()), ..Default::default() }
+    }
    pub fn is_placeholder(&self) -> bool {
        self.ph.is_some()
    }
@@ -113,7 +113,15 @@ fn general(v: f64, dec: char) -> String {
    }
    let a = v.abs();
    let s = if !(1e-9..1e11).contains(&a) {
-        format!("{v:.5E}")
+        let s = format!("{v:.5E}");
+        match s.split_once('E') {
+            Some((m, e)) => {
+                let m = if m.contains('.') { m.trim_end_matches('0').trim_end_matches('.') } else { m };
+                let e: i32 = e.parse().unwrap_or(0);
+                format!("{m}E{}{:02}", if e < 0 { '-' } else { '+' }, e.abs())
+            }
+            None => s,
+        }
    } else {
        let digits = (10 - (a.log10().floor() as i32 + 1)).clamp(0, 10) as usize;
        let s = format!("{v:.digits$}");
@@ -150,7 +158,7 @@ pub fn format(code: &str, v: f64, lang: Option<&str>) -> String {
        ([pos, ..], v) => (*pos, v.abs(), v < 0.0),
        ([], v) => ("General", v.abs(), v < 0.0),
    };
-    if sec.trim().eq_ignore_ascii_case("general") || sec.trim().is_empty() {
+    if sec.trim().eq_ignore_ascii_case("general") || (secs.len() == 1 && sec.trim().is_empty()) {
        let s = general(v, dec);
        return if minus { format!("-{s}") } else { s };
    }
@@ -204,7 +212,12 @@ fn sci(toks: &[Tok], v: f64, sep: char, dec: char) -> Option<String> {
    let (mut m, mut exp) = (0.0, 0i32);
    if v != 0.0 {
        exp = v.log10().floor() as i32;
-        m = v / 10f64.powi(exp);
+        m = if exp < -300 {
+            // 10^exp underflows for subnormals; scale in two steps.
+            v * 1e300 / 10f64.powi(exp + 300)
+        } else {
+            v / 10f64.powi(exp)
+        };
        if !m.is_finite() {
            m = 0.0;
            exp = 0;
@@ -253,7 +266,7 @@ fn fixed(toks: &[Tok], first: usize, last: usize, v: f64, sep: char, dec: char)
    let grouping = int_part.iter().any(|t| *t == Tok::Comma || matches!(t, Tok::Lit(s) if s.trim().is_empty()));
    // Commas right after the last digit scale by a thousand each (`#,##0,` = thousands).
    let after = toks.get(last + 1..).unwrap_or(&[]);
-    let scale_commas = if dot.is_none() { after.iter().take_while(|t| **t == Tok::Comma).count() } else { 0 };
+    let scale_commas = after.iter().take_while(|t| **t == Tok::Comma).count();
    let min_int = int_part.iter().filter(|t| **t == Tok::Digit('0')).count();
    let frac_digits: Vec<char> = frac_part.iter().filter_map(|t| if let Tok::Digit(c) = t { Some(*c) } else { None }).collect();
    let max_frac = frac_digits.len();
@@ -286,6 +299,12 @@ mod tests {

    const RUB: &str = r#"_-* #\ ##0\ "₽"_-;\-* #\ ##0\ "₽"_-;_-* "-"??\ "₽"_-;_-@_-"#;

+    #[test]
+    fn scientific_subnormal() {
+        assert_eq!(format("0.00E+00", 5e-324, None), "4.94E-324");
+        assert_eq!(format("0.00E+00", f64::MIN_POSITIVE, None), "2.23E-308");
+    }
+
    #[test]
    fn russian_accounting_roubles() {
        assert_eq!(format(RUB, 800_000.0, Some("ru-RU")), "800\u{a0}000 ₽");
@@ -304,6 +323,10 @@ mod tests {
        assert_eq!(format("0%", 0.0, None), "0%");
        assert_eq!(format("General", 2.5, Some("ru-RU")), "2,5");
        assert_eq!(format("General", 400_000.0, Some("ru-RU")), "400000");
+        assert_eq!(format("General", 1.5e12, None), "1.5E+12");
+        assert_eq!(format("General", 1e-10, None), "1E-10");
+        assert_eq!(format("General", -2.5e-12, None), "-2.5E-12");
+        assert_eq!(format("General", 1e100, None), "1E+100");
        assert_eq!(format("0.00", 1.23456, None), "1.23");
        assert_eq!(format("#,##0.0#", 1234.5, None), "1,234.5");
        assert_eq!(format("#,##0,", 12_345_678.0, None), "12,346");
@@ -314,6 +337,42 @@ mod tests {
        assert_eq!(format("\"x\"0", 5.0, None), "x5");
    }

+    #[test]
+    fn trailing_commas_with_decimals() {
+        assert_eq!(format("0.0,,", 15_000_000.0, Some("en-US")), "15.0");
+        assert_eq!(format("0.00,\"K\"", 15_000.0, Some("en-US")), "15.00K");
+    }
+
+    #[test]
+    fn explicit_empty_sections_hide_their_values() {
+        for v in [3.0, -3.0, 0.0, -0.0] {
+            assert_eq!(format(";;;", v, None), "", "all sections empty: {v}");
+        }
+        for (code, positive, negative, zero) in [
+            (";0;0", "", "3", "0"),
+            ("0;;0", "3", "", "0"),
+            ("0;-0;", "3", "-3", ""),
+            (";0", "", "3", ""),
+            (r#"";"0;;"#, ";3", "", ""),
+            (r"\;0;;", ";3", "", ""),
+        ] {
+            assert_eq!(format(code, 3.0, None), positive, "positive: {code}");
+            assert_eq!(format(code, -3.0, None), negative, "negative: {code}");
+            assert_eq!(format(code, 0.0, None), zero, "zero: {code}");
+        }
+        assert_eq!(format("0;-0;", -0.0, None), "");
+    }
+
+    #[test]
+    fn blank_whole_codes_and_general_keep_their_fallback() {
+        for code in ["", " \t", "General", " general "] {
+            assert_eq!(format(code, 2.5, None), "2.5", "{code:?}");
+            assert_eq!(format(code, -2.5, None), "-2.5", "{code:?}");
+            assert_eq!(format(code, 0.0, None), "0", "{code:?}");
+            assert_eq!(format(code, 2.5, Some("de-DE")), "2,5", "{code:?}");
+        }
+    }
+
    #[test]
    fn scientific_formats() {
        assert_eq!(format("0.00E+00", 1234.0, None), "1.23E+03");
@@ -100,8 +100,15 @@ pub fn parents<'a>(ctx: &Ctx<'a>, shape: &Shape) -> (Option<&'a Shape>, Option<&
    }
 }

-/// The text style group (title / body / other) a shape draws from.
+/// The text style group (title / body / other) a shape draws from. Text in a table takes the
+/// master's other-text style, also when the table sits in a content placeholder, as in PowerPoint
+/// for Mac (a table cell is 14 pt under an `otherStyle` of 14 pt, a `defaultTextStyle` of 26 pt and
+/// a bulleted 36 pt `bodyStyle`, with or without `<p:ph idx="1"/>`, while a shape's or a text box's
+/// text is 26 pt); other shapes take the presentation's default text style.
 pub fn master_list_style<'a>(ctx: &Ctx<'a>, shape: &Shape) -> &'a ListStyle {
+    if matches!(shape.kind, crate::ShapeKind::Table(_)) {
+        return &ctx.master.other_style;
+    }
    match shape.ph_type() {
        Some(PhType::Title | PhType::CtrTitle) => &ctx.master.title_style,
        Some(
@@ -248,7 +255,9 @@ pub fn body(ctx: &Ctx, shape: &Shape) -> BodyProps {

 /// The merged level style (paragraph + run defaults) for paragraphs at `level` in `shape`.
 pub fn level_style(ctx: &Ctx, shape: &Shape, level: u8) -> LevelStyle {
-    let (lp, mp) = parents(ctx, shape);
+    // A table's text inherits nothing from a placeholder the table sits in: PowerPoint draws it in
+    // the other-text style even under list styles on the layout's and master's placeholders.
+    let (lp, mp) = if matches!(shape.kind, crate::ShapeKind::Table(_)) { (None, None) } else { parents(ctx, shape) };
    let mut out = LevelStyle::default();
    let add = |out: &mut LevelStyle, ls: Option<&LevelStyle>| {
        if let Some(l) = ls {
@@ -270,3 +270,27 @@ fn ink_width_follows_pressure_and_keeps_the_old_placeholder() {
    assert!((floor - 0.64).abs() < 1e-4, "a light touch stays visible, got {floor}");
    assert!((ink_sample_width(8.0, f32::NAN, false) - 8.0).abs() < 1e-9);
 }
+
+#[test]
+fn table_text_takes_the_masters_other_style_and_shapes_the_default_text_style() {
+    // PowerPoint for Mac, with an otherStyle of 14 pt, a defaultTextStyle of 26 pt and a 36 pt
+    // bodyStyle: a table cell's text is 14 pt, also in a table placed in a content placeholder; a
+    // shape's and a text box's is 26 pt.
+    let mut p = Presentation::default();
+    let size = |pt: f64| crate::text::LevelStyle { run: RunProps { size: Some(pt), ..Default::default() }, ..Default::default() };
+    p.default_text_style.set(0, size(26.0));
+    std::sync::Arc::make_mut(&mut p.masters[0]).other_style.set(0, size(14.0));
+    std::sync::Arc::make_mut(&mut p.masters[0]).body_style.set(0, size(36.0));
+    let s = p.slides[0].clone();
+    let ctx = Ctx::for_slide(&p, &s).unwrap();
+    let para = Paragraph::default();
+    let pt = |sh: &Shape| resolve::run(&ctx, sh, &para, &RunProps::default()).size;
+    let body = crate::text::TextBody::from_text("Cell");
+    assert_eq!(pt(&Shape::table_cell(body.clone())), Some(14.0), "a table cell");
+    let table = Shape { kind: ShapeKind::Table(Table::default()), ..Default::default() };
+    assert_eq!(pt(&table), Some(14.0), "the table itself (its formatting state)");
+    let in_placeholder = Shape { ph: Some(Placeholder { kind: PhType::Obj, idx: 1, ..Default::default() }), ..table };
+    assert_eq!(pt(&in_placeholder), Some(14.0), "a table in a content placeholder");
+    assert_eq!(pt(&Shape { text: Some(body.clone()), ..Default::default() }), Some(26.0), "a shape");
+    assert_eq!(pt(&Shape { text: Some(body), text_box: true, ..Default::default() }), Some(26.0), "a text box");
+}
@@ -603,6 +603,7 @@ pub struct TextBody {

 impl TextBody {
    pub fn from_text(text: &str) -> Self {
+        let text = text.replace("\r\n", "\n").replace('\r', "\n");
        TextBody { paragraphs: text.split('\n').map(Paragraph::new).collect(), ..Default::default() }
    }
    /// Plain text with `\n` between paragraphs.
@@ -500,11 +500,12 @@ fn x_pow(p: f64) -> String {
 }

 fn poly_equation(coeff: &[f64]) -> Option<String> {
-    let scale = coeff.iter().map(|c| c.abs()).fold(0.0, f64::max).max(1.0);
+    // Drop terms that are negligible relative to the largest coefficient, so tiny-valued data keeps its terms.
+    let scale = coeff.iter().map(|c| c.abs()).fold(0.0, f64::max);
    let mut body = String::new();
    let mut first = true;
    for (k, c) in coeff.iter().enumerate().rev() {
-        if c.abs() < scale * 1e-8 {
+        if c.abs() <= scale * 1e-8 {
            continue;
        }
        let pow = match k {
@@ -514,7 +515,7 @@ fn poly_equation(coeff: &[f64]) -> Option<String> {
        };
        let mag = if pow.is_empty() {
            num(c.abs())
-        } else if (c.abs() - 1.0).abs() < scale * 1e-8 {
+        } else if (c.abs() - 1.0).abs() < scale.max(1.0) * 1e-8 {
            pow
        } else {
            format!("{}{}", num(c.abs()), pow)
@@ -620,4 +621,21 @@ mod tests {
        let fit = t.fit(&[1.0, 2.0, 3.0], &[1.0, 2.0, 3.0]).expect("fit");
        assert_eq!(t.caption(&fit), "y = x\nR² = 1");
    }
+
+    #[test]
+    fn equation_keeps_tiny_coefficients() {
+        let xs = [1.0, 2.0, 3.0, 4.0];
+        let lin = line(TrendlineType::Linear).fit(&xs, &[2e-9, 4e-9, 6e-9, 8e-9]).expect("linear");
+        assert_eq!(lin.equation().as_deref(), Some("y = 2.00e-9x"));
+        let mut poly = line(TrendlineType::Poly);
+        poly.order = Some(2);
+        let ys: Vec<f64> = xs.iter().map(|x| 3e-9 * x * x + 1e-9).collect();
+        let quad = poly.fit(&xs, &ys).expect("poly");
+        assert_eq!(quad.equation().as_deref(), Some("y = 3.00e-9x² + 1.00e-9"));
+        let ys: Vec<f64> = xs.iter().map(|x: &f64| 5e-9 * x.ln()).collect();
+        let log = line(TrendlineType::Log).fit(&xs, &ys).expect("log");
+        assert_eq!(log.equation().as_deref(), Some("y = 5.00e-9ln(x)"));
+        let zero = line(TrendlineType::Linear).fit(&xs, &[0.0; 4]).expect("zero");
+        assert_eq!(zero.equation().as_deref(), Some("y = 0"));
+    }
 }
@@ -20,7 +20,7 @@ thiserror = { workspace = true }
 log = { workspace = true }

 [dev-dependencies]
-hayro-syntax = { version = "=0.7.2", default-features = false, features = ["std"] }
+hayro-syntax = { version = "=0.8.0", default-features = false, features = ["std"] }

 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 wasm-bindgen-test = "0.3"
@@ -29,4 +29,4 @@ wasm-bindgen-test = "0.3"
 # slide renders (the same bytes, in parallel). The root patch selects the same pinned
 # backend as craft-pdf; this dependency only enables its native compression feature.
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-krilla = { version = "=0.8.2", features = ["rayon"] }
+krilla = { version = "=0.8.2", default-features = false, features = ["rayon"] }
@@ -66,7 +66,7 @@ pub enum PageLayout {
 #[serde(default, rename_all = "camelCase")]
 pub struct PdfOptions {
    pub layout: PageLayout,
-    /// Raster resolution of slide artwork (dots per inch).
+    /// Raster resolution of slide artwork (dots per inch), lowered for a slide whose raster would pass 64M pixels.
    pub dpi: f64,
    /// Slide indices to export (0-based); `None` = all.
    pub slides: Option<Vec<usize>>,
@@ -423,6 +423,16 @@ fn backdrop(mut img: deckcraft_render::Image) -> Image {
    Image::from_rgba8(img.pixels, img.width, img.height)
 }

+/// Most pixels one slide raster may have; it is RGBA, and the backdrop and the content are two rasters.
+const MAX_RASTER_PIXELS: f64 = 64_000_000.0;
+
+/// Render scale for a slide of `slide` units drawn `box_width` points wide at `dpi`, with the total pixel count capped.
+fn raster_scale(box_width: f64, slide: (f64, f64), dpi: f64) -> f64 {
+    let scale = (box_width / 72.0 * dpi.clamp(36.0, 600.0)) / slide.0;
+    let pixels = slide.0 * scale * slide.1 * scale;
+    if pixels > MAX_RASTER_PIXELS { scale * (MAX_RASTER_PIXELS / pixels).sqrt() } else { scale }
+}
+
 impl Exporter<'_> {
    fn font(&mut self, face: &deckcraft_fonts::FontFace) -> Result<Font> {
        if let Some(font) = self.fonts.get(&face.id()) {
@@ -439,7 +449,7 @@ impl Exporter<'_> {
        let (sw, sh) = (pres.slide_size.width.max(1.0), pres.slide_size.height.max(1.0));
        let k = b.width() / sw;
        // Raster at the requested dpi relative to the box size on paper.
-        let scale = (b.width() / 72.0 * self.opts.dpi.clamp(36.0, 600.0)) / sw;
+        let scale = raster_scale(b.width(), (sw, sh), self.opts.dpi);
        let ropts = RenderOpts { scale, threads: 4, ..Default::default() };
        // Two rasters per slide: the backdrop (background, master and layout graphics) is the same
        // on every slide that shares its layout, so the writer stores it once, and the slide's own
@@ -530,3 +530,14 @@ fn glyph_ranges_follow_shaping_clusters() {
    // A run starting mid-paragraph, multi-byte characters in visual (right-to-left) order.
    assert_eq!(glyph_text_ranges("αβγ", (3, 6), &[(5, 'γ'), (4, 'β'), (3, 'α')], 3), vec![4..6, 2..4, 0..2]);
 }
+
+#[test]
+fn raster_scale_caps_total_pixels_not_each_side() {
+    // A huge square slide at 600 dpi would be 16,000 x 16,000 px (~1 GB RGBA) without the cap.
+    let s = raster_scale(20_000.0, (20_000.0, 20_000.0), 600.0);
+    let px = 20_000.0 * s * 20_000.0 * s;
+    assert!(px <= MAX_RASTER_PIXELS * 1.0001, "{px}");
+    // A normal slide keeps the requested dpi.
+    let s = raster_scale(720.0, (960.0, 540.0), 200.0);
+    assert!((s - 720.0 / 72.0 * 200.0 / 960.0).abs() < 1e-12);
+}
@@ -281,8 +281,8 @@ fn percent_decode(s: &str) -> String {

 /// Resolve a relative target against a base directory into a part name.
 pub fn resolve(base: &str, target: &str) -> String {
-    let target = percent_decode(target);
-    let target = target.split('#').next().unwrap_or("");
+    let target = percent_decode(target.split('#').next().unwrap_or(""));
+    let target = target.as_str();
    let mut segs: Vec<&str> = if target.starts_with('/') { vec![] } else { base.split('/').filter(|s| !s.is_empty()).collect() };
    for s in target.split('/') {
        match s {
@@ -441,6 +441,12 @@ impl PackageOut {
 mod tests {
    use super::*;

+    #[test]
+    fn resolve_keeps_encoded_hash_and_strips_fragment() {
+        assert_eq!(resolve("ppt/slides", "../media/a%23b.png"), "ppt/media/a#b.png");
+        assert_eq!(resolve("ppt/slides", "../media/a.png#frag"), "ppt/media/a.png");
+    }
+
    fn zip_of(entries: &[(&str, usize)]) -> Vec<u8> {
        let mut zw = zip::ZipWriter::new(Cursor::new(Vec::new()));
        let o = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
@@ -781,24 +781,14 @@ pub fn color_map(cm: &El) -> Vec<(String, String)> {
    cm.attrs.iter().filter(|(k, _)| !k.starts_with("xmlns")).map(|(k, v)| (k.clone(), v.clone())).collect()
 }

-/// The anchor the theme's shape defaults (`a:objectDefaults/a:spDef/a:bodyPr`) give new shapes
-/// text, if any.
-fn theme_shape_anchor(t: &deckcraft_model::Theme) -> Option<deckcraft_model::text::Anchor> {
-    let raw = t.raw_extra.as_deref()?;
-    let sp = &raw[raw.find("spDef")?..];
-    let sp = &sp[..sp.find("/a:spDef").or_else(|| sp.find("txDef")).unwrap_or(sp.len())];
-    let b = &sp[sp.find("bodyPr")?..];
-    let b = &b[..b.find('>').unwrap_or(b.len())];
-    let v = &b[b.find("anchor=\"")? + 8..];
-    deckcraft_model::text::Anchor::from_xml(&v[..v.find('"')?])
-}
-
-/// A shape's text without an anchor of its own sits at the top, as the standard has it (or where
-/// the theme's shape defaults put it). The model's own default for shapes is the middle, so a
-/// top or bottom anchor is made explicit here and a middle one left unset (placeholders and text
-/// boxes keep inheriting).
+/// A shape's text without an anchor of its own sits at the top, as the standard has it and as
+/// PowerPoint draws it. The theme's shape defaults (`a:objectDefaults/a:spDef/a:bodyPr`, centred in
+/// Office's themes) are for shapes inserted later, not for the file's own shapes: PowerPoint for
+/// Mac draws `<a:bodyPr/>` at the top under an `spDef` with `anchor="ctr"`. The model's own default
+/// for shapes is the middle, so a top or bottom anchor is made explicit here and a middle one left
+/// unset (placeholders and text boxes keep inheriting).
 fn default_text_anchor(p: &mut Presentation) {
-    fn fix(shapes: &mut [deckcraft_model::Shape], a: deckcraft_model::text::Anchor) {
+    fn fix(shapes: &mut [deckcraft_model::Shape]) {
        walk_shapes_mut(shapes, &mut |s| {
            if s.ph.is_none()
                && !s.text_box
@@ -806,25 +796,20 @@ fn default_text_anchor(p: &mut Presentation) {
                && let Some(t) = &mut s.text
            {
                // Middle is the model's own default for shapes, so it is kept as unset.
-                let got = t.body.anchor.unwrap_or(a);
+                let got = t.body.anchor.unwrap_or(deckcraft_model::text::Anchor::Top);
                t.body.anchor = (got != deckcraft_model::text::Anchor::Middle).then_some(got);
            }
        });
    }
-    let top = deckcraft_model::text::Anchor::Top;
-    let anchors: Vec<_> = p.masters.iter().map(|m| (m.id, theme_shape_anchor(&m.theme).unwrap_or(top))).collect();
    for m in &mut p.masters {
-        let a = anchors.iter().find(|(id, _)| *id == m.id).map(|x| x.1).unwrap_or(top);
        let m = Arc::make_mut(m);
-        fix(&mut m.shapes, a);
+        fix(&mut m.shapes);
        for l in &mut m.layouts {
-            fix(&mut l.shapes, a);
+            fix(&mut l.shapes);
        }
    }
-    let per_slide: Vec<_> =
-        p.slides.iter().map(|s| p.master_for(s).and_then(|(m, _)| anchors.iter().find(|(id, _)| *id == m.id)).map(|x| x.1).unwrap_or(top)).collect();
-    for (s, a) in p.slides.iter_mut().zip(per_slide) {
-        fix(&mut Arc::make_mut(s).shapes, a);
+    for s in &mut p.slides {
+        fix(&mut Arc::make_mut(s).shapes);
    }
 }

@@ -347,8 +347,14 @@ fn pic(imp: &mut Imp, part: &Part, ctx: &mut IdCtx, e: &El) -> Shape {
    if vf.is_some() || af.is_some() || p14.is_some() {
        let media = p14.and_then(|m| dml::media_ref(imp, part, m)).or_else(|| vf.or(af).and_then(|f| dml::media_ref(imp, part, f)));
        if let Some(media) = media {
-            let mut clip =
-                MediaClip { media, video: vf.is_some() || af.is_none(), poster: pf.as_ref().map(|p| p.media), volume: 1.0, ..Default::default() };
+            let mut clip = MediaClip {
+                media,
+                video: vf.is_some() || af.is_none(),
+                poster: pf.as_ref().map(|p| p.media),
+                crop: pf.as_ref().map(|p| p.crop).unwrap_or_default(),
+                volume: 1.0,
+                ..Default::default()
+            };
            if let Some(m) = p14 {
                if let Some(t) = m.child("trim") {
                    clip.trim_start_ms = ms(t.attr("st"));
@@ -876,7 +876,7 @@ fn author_slot(c: &Comment, authors: &mut Vec<(String, String, u32)>) -> usize {
 /// the flattened legacy part cannot express (issue #70).
 fn modern_comments_xml(list: &[Comment], part: &str, authors: &mut Vec<(String, String, u32)>) -> Vec<u8> {
    let mut w = W::new();
-    w.open("p188:cmLst", A::new().a("xmlns:p188", NS_P188));
+    w.open("p188:cmLst", A::new().a("xmlns:p188", NS_P188).a("xmlns:a", NS_A).a("xmlns:r", NS_R));
    for (ti, c) in list.iter().take(10_000).enumerate() {
        modern_comment(&mut w, c, part, ti, authors, 0);
    }
@@ -828,7 +828,7 @@ fn media(w: &mut W, x: &mut Exp, o: &mut Out, id: u32, s: &Shape, m: &deckcraft_
    }
    w.close("p:nvPr");
    w.close("p:nvPicPr");
-    let poster = deckcraft_model::style::PictureFill { media: m.poster.unwrap_or_default(), ..Default::default() };
+    let poster = deckcraft_model::style::PictureFill { media: m.poster.unwrap_or_default(), crop: m.crop, ..Default::default() };
    dml::blip_fill(w, x, o, "p:blipFill", &poster);
    let mut s3 = s.clone();
    s3.fill = None;
@@ -367,6 +367,7 @@ pub fn esc(s: &str) -> String {
            '&' => o.push_str("&amp;"),
            '<' => o.push_str("&lt;"),
            '>' => o.push_str("&gt;"),
+            '\r' => o.push_str("&#13;"),
            c if xml_char(c) => o.push(c),
            _ => {}
        }
@@ -506,6 +507,15 @@ mod tests {
        assert_eq!(t, vec!["one\ntwo\nthree\rfour".to_string(), "x\ny".to_string()]);
    }

+    #[test]
+    fn cr_in_text_survives_write_read() {
+        assert_eq!(esc("a\rb"), "a&#13;b");
+        let mut w = W::default();
+        w.elt("a:t", "one\rtwo\r\nthree");
+        let d = parse(w.s.as_bytes()).expect("parse");
+        assert_eq!(d.root.text(), "one\rtwo\r\nthree");
+    }
+
    #[test]
    fn parse_basic_and_entities() {
        let d = parse(b"<?xml version=\"1.0\"?><a:p xmlns:a=\"x\"><a:r><a:t>A &amp; B &#x41; &lt;</a:t></a:r><a:x r:id=\"rId1\" id=\"5\"/></a:p>")
@@ -1,5 +1,5 @@
 //! Text anchoring of shapes without an `anchor` of their own: the model centres a shape's text,
-//! a file without one puts it at the top (or where the theme's shape defaults say).
+//! a file without one puts it at the top, whatever the theme's shape defaults say.

 use std::io::{Cursor, Read, Write};

@@ -57,7 +57,8 @@ fn shapes_keep_their_middle_anchor_and_files_without_one_anchor_at_the_top() {
    let a = anchors(&deckcraft_pptx::import(&bare).expect("import"));
    assert!(a.iter().all(|x| *x == Some(Anchor::Top)), "{a:?}");

-    // ...unless the theme's shape defaults centre them, as Office's themes do.
+    // Also when the theme's shape defaults centre new shapes, as Office's themes do: PowerPoint
+    // for Mac draws `<a:bodyPr/>` at the top under such an `spDef` (synthetic probe exported as PDF).
    let themed = rewrite(&bare, |n, x| {
        if n.starts_with("ppt/theme/") {
            x.replace(
@@ -69,6 +70,5 @@ fn shapes_keep_their_middle_anchor_and_files_without_one_anchor_at_the_top() {
        }
    });
    let a = anchors(&deckcraft_pptx::import(&themed).expect("import"));
-    assert!(a.iter().all(|x| x.is_none() || *x == Some(Anchor::Middle)), "{a:?}");
-    assert!(a.iter().filter(|x| x.is_none()).count() >= 3, "{a:?}");
+    assert!(a.iter().all(|x| *x == Some(Anchor::Top)), "{a:?}");
 }
@@ -206,3 +206,46 @@ fn modern_only_package_imports() {
    assert!(b[0].resolved);
    assert_eq!((b[0].x, b[0].y), (90.0, 45.0), "modern positions are EMU");
 }
+
+/// Every prefix an exported part uses is bound: PowerPoint refuses a package whose part is not
+/// namespace-well-formed (issue #974, the modern comments part used `a:` without declaring it).
+#[test]
+fn every_written_xml_part_binds_its_prefixes() {
+    use quick_xml::events::Event;
+    use quick_xml::name::ResolveResult;
+
+    let bytes = deckcraft_pptx::export(&deck()).expect("export");
+    let mut z = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).expect("zip");
+    let mut modern = 0;
+    for i in 0..z.len() {
+        let mut f = z.by_index(i).expect("entry");
+        let name = f.name().to_string();
+        if !(name.ends_with(".xml") || name.ends_with(".rels")) {
+            continue;
+        }
+        let mut data = vec![];
+        f.read_to_end(&mut data).expect("read");
+        modern += usize::from(name.contains("modernComment"));
+        let mut r = quick_xml::NsReader::from_reader(data.as_slice());
+        loop {
+            match r.read_resolved_event() {
+                Ok((ns, Event::Start(e) | Event::Empty(e))) => {
+                    assert!(!matches!(ns, ResolveResult::Unknown(_)), "{name}: unbound prefix on <{}>", String::from_utf8_lossy(e.name().as_ref()));
+                    for attr in e.attributes() {
+                        let attr = attr.unwrap_or_else(|err| panic!("{name}: bad attribute: {err}"));
+                        let (ns, _) = r.resolver().resolve_attribute(attr.key);
+                        assert!(
+                            !matches!(ns, ResolveResult::Unknown(_)),
+                            "{name}: unbound prefix on attribute {}",
+                            String::from_utf8_lossy(attr.key.as_ref())
+                        );
+                    }
+                }
+                Ok((_, Event::Eof)) => break,
+                Ok(_) => {}
+                Err(e) => panic!("{name}: not well-formed: {e}"),
+            }
+        }
+    }
+    assert!(modern > 0, "the deck should write a modern comments part");
+}
--- a/Show More
+++ b/Show More